llt-form_builder 0.0.1

data/spec/lib/llt/form_builder/ethnic_builder_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe LLT::FormBuilder do
+  describe ".build" do
+    context "with ethnics" do
+      context "with options" do
+        it "builds only correct forms" do
+          opts = { stem: "Haedu", ending: "orum" }
+          args = { type: :ethnic, stem: "Haedu", inflection_class: 1, options: opts }
+          forms = LLT::FormBuilder.build(args)
+          forms.should have(2).items
+          forms.first.to_s.should == "Haeduorum" # check if it's still capitalized
+        end
+      end
+    end
+  end
+end

data/spec/lib/llt/form_builder/form_builder_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe LLT::FormBuilder do
+  include LLT::Helpers::Normalizer
+
+  describe ".build" do
+    def form_builder_strings(args)
+      forms = LLT::FormBuilder.build(*args)
+      forms.map(&:to_s)
+    end
+
+    it "has a version" do
+      LLT::FormBuilder::VERSION.should_not be_nil
+    end
+  end
+end

data/spec/lib/llt/form_builder/fp_builder_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe LLT::FormBuilder do
+  include LLT::Helpers::Normalizer
+
+  describe ".build" do
+    def form_builder_strings(args)
+      forms = LLT::FormBuilder.build(*args)
+      forms.map(&:to_s)
+    end
+
+    context "with fp" do
+      it "builds all forms - a conj" do
+        args = [{type: :fp, stem: "amat", inflection_class: 1, tense: :pf}]
+        form_builder_strings(args).should == %w{ amaturus amaturi amaturo amaturum amature amaturo amaturi amaturorum amaturis amaturos amaturi amaturis
+                                                   amatura amaturae amaturae amaturam amatura amatura amaturae amaturarum amaturis amaturas amaturae amaturis
+                                                   amaturum amaturi amaturo amaturum amaturum amaturo amatura amaturorum amaturis amatura amatura amaturis }
+      end
+
+      context "with options that select a specfic form given in a stem" do
+        it "builds correct forms only (several possibilities)" do
+          options = { casus: 2 }
+          args = [{type: :fp, stem: "amat", inflection_class: 1,
+            tense: :fut, options: options}]
+          forms = LLT::FormBuilder.build(*args)
+
+          forms.should have(6).items
+          form = forms[2]
+
+          form.casus.should == 2
+          form.numerus.should == 1
+          form.sexus.should == :f
+
+          form.participium?.should be_true
+
+          form.tempus.should == t.fut
+          form.genus.should  == t.act
+        end
+      end
+    end
+  end
+end

data/spec/lib/llt/form_builder/gerund_builder_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe LLT::FormBuilder do
+  include LLT::Helpers::Normalizer
+
+  describe ".build" do
+    def form_builder_strings(args)
+      forms = LLT::FormBuilder.build(*args)
+      forms.map(&:to_s)
+    end
+
+    context "with gerunds" do
+      context "build all forms" do
+        it "a conj" do
+          args = [{type: :gerund, stem: "ama", inflection_class: 1, tense: :pr}]
+          forms = LLT::FormBuilder.build(*args)
+          forms.map(&:to_s).should == %w{ amandi amando amandum amando }
+          forms[0].casus.should == 2
+          forms[3].casus.should == 6
+        end
+
+        it "c conj" do
+          args = [{type: :gerund, stem: "leg", inflection_class: 3, tense: :pr}]
+          forms = LLT::FormBuilder.build(*args)
+          forms.map(&:to_s).should == %w{ legendi legendo legendum legendo }
+          forms[0].casus.should == 2
+          forms[3].casus.should == 6
+        end
+      end
+    end
+
+    context "with options that select a specfic form given in a stem" do
+      context "with gerunds" do
+        it "builds correct forms only (several possibilities)" do
+          options = { casus: 4 }
+          args = [{type: :gerund, stem: "ama", inflection_class: 1, options: options}]
+          forms = LLT::FormBuilder.build(*args)
+
+          forms.should have(1).items
+          form = forms[0]
+
+          form.casus.should == 4
+          form.numerus.should == 1
+          form.sexus.should == :n
+          form.ending.should == "um"
+          form.extension.should == "nd"
+
+          form.gerund?.should be_true
+
+          form.tempus.should be_nil
+          form.genus.should  be_nil
+        end
+
+        it "builds correct forms only, ending given" do
+          options = { ending: "um" }
+          args = [{type: :gerund, stem: "ama", inflection_class: 1, options: options}]
+          forms = LLT::FormBuilder.build(*args)
+          forms.should have(1).item
+          forms.first.casus.should == 4
+        end
+
+        context "with validate flag" do
+          it "doesn't build forms when extension is not given" do
+            options = { ending: "um", validate: true }
+            args = [{type: :gerund, stem: "ama", inflection_class: 1, options: options}]
+            forms = LLT::FormBuilder.build(*args)
+            forms.should be_empty
+          end
+
+          it "needs the extension to be given" do
+            options = { ending: "um", extension: "nd", validate: true }
+            args = [{type: :gerund, stem: "ama", inflection_class: 1, options: options}]
+            forms = LLT::FormBuilder.build(*args)
+            forms.should have(1).items
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/llt/form_builder/gerundive_builder_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe LLT::FormBuilder do
+  include LLT::Helpers::Normalizer
+
+  describe ".build" do
+    def form_builder_strings(args)
+      forms = LLT::FormBuilder.build(*args)
+      forms.map(&:to_s)
+    end
+
+    context "with gerundiva" do
+      context "build all forms" do
+        it "a conj" do
+          args = [{type: :gerundive, stem: "ama", inflection_class: 1, tense: :pr}]
+          form_builder_strings(args).should == %w{ amandus amandi amando amandum amande amando amandi amandorum amandis amandos amandi amandis
+                                                   amanda amandae amandae amandam amanda amanda amandae amandarum amandis amandas amandae amandis
+                                                   amandum amandi amando amandum amandum amando amanda amandorum amandis amanda amanda amandis }
+        end
+
+        it "m conj" do
+          args = [{type: :gerundive, stem: "cap", inflection_class: 5, tense: :pr}]
+          form_builder_strings(args).should == %w{ capiendus capiendi capiendo capiendum capiende capiendo capiendi capiendorum capiendis capiendos capiendi capiendis
+                                                   capienda capiendae capiendae capiendam capienda capienda capiendae capiendarum capiendis capiendas capiendae capiendis
+                                                   capiendum capiendi capiendo capiendum capiendum capiendo capienda capiendorum capiendis capienda capienda capiendis }
+        end
+      end
+    end
+
+    context "with options that select a specfic form given in a stem" do
+      context "with gerundives" do
+        it "builds correct forms only (several possibilities)" do
+          options = { numerus: 2 }
+          args = [{type: :gerundive, stem: "ama", inflection_class: 1, options: options}]
+          forms = LLT::FormBuilder.build(*args)
+
+          forms.should have(18).items
+          form = forms.last
+
+          form.casus.should == 6
+          form.numerus.should == 2
+          form.sexus.should == :n
+          form.ending.should == "is"
+          form.extension.should == "nd"
+
+          form.gerundive?.should be_true
+
+          form.tempus.should be_nil
+          form.genus.should  be_nil
+        end
+
+        it "builds correct forms only, ending given" do
+          options = { ending: "um" }
+          args = [{type: :gerundive, stem: "ama", inflection_class: 1, options: options}]
+          forms = LLT::FormBuilder.build(*args)
+          forms.should have(4).items
+          forms.map(&:casus).should == [4, 1, 4, 5]
+          forms.map(&:sexus).should == %i{ m n n n }
+        end
+
+        context "with validate flag" do
+          it "needs the extension to be given" do
+            options = { ending: "um", extension: "nd", validate: true }
+            args = [{type: :gerundive, stem: "ama", inflection_class: 1, options: options}]
+            forms = LLT::FormBuilder.build(*args)
+            forms.should have(4).items
+          end
+
+          it "doesn't build forms when extension is not given" do
+            # no extension given, no result
+            options = { ending: "um", validate: true }
+            args = [{type: :gerundive, stem: "ama", inflection_class: 1, options: options}]
+            forms = LLT::FormBuilder.build(*args)
+            forms.should be_empty
+          end
+
+          context "with archaic forms" do
+            let(:archaic_forms) do
+              options = { thematic: "u", extension: "nd", ending: "i", validate: true }
+              args = { type: :gerundive, stem: "audi", inflection_class: 4, options: options }
+              LLT::FormBuilder.build(args)
+            end
+
+            it "builds the correct forms" do
+              archaic_forms.should have(4).items
+              archaic_forms.map(&:numerus).should =~ [1, 2, 2, 1]
+              archaic_forms.map(&:casus).should =~ [2, 1, 5, 2]
+            end
+
+            it "produces the correct string value for archaic forms" do
+              archaic_forms.map(&:to_s).should == %w{ audiundi } * 4
+            end
+
+            it "marks forms as archaic" do
+              archaic_forms.map(&:classification).should == %i{ archaic } * 4
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/llt/form_builder/helpers/stem_hash_parser_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+
+describe LLT::FormBuilder::StemHashParser do
+  def shp(arg)
+    LLT::FormBuilder::StemHashParser.new(arg)
+  end
+
+  include LLT::Helpers::Normalizer
+
+  describe "#parse" do
+    context "with praesens" do
+      it "changes type to gerund and gerundive with options extensions: 'nd'" do
+        args = [{type: :praesens, stem: "ama", inflection_class: 1, options: { extension: "nd" }}]
+        shp(args).parse.should =~ [{type: :gerund, stem: "ama", inflection_class: 1, options: { extension: "nd" }},
+                                   {type: :gerundive, stem: "ama", inflection_class: 1, options: { extension: "nd" }} ]
+      end
+
+      it "changes type to gerund with options modus: 'gerund'" do
+        args = [{type: :praesens, stem: "ama", inflection_class: 1, options: { modus: "gerund" }}]
+        shp(args).parse.should =~ [{type: :gerund, stem: "ama", inflection_class: 1, options: { modus: :gerundium }}]
+      end
+
+      it "changes type to gerundive with options modus: 'gerundive'" do
+        args = [{type: :praesens, stem: "ama", inflection_class: 1, options: { modus: "gerundive" }}]
+        shp(args).parse.should =~ [{type: :gerundive, stem: "ama", inflection_class: 1, options: { modus: :gerundivum }}]
+      end
+
+      it "changes type to ppa with options extension: 'nt' or 'n'" do
+        args = [{type: :praesens, stem: "ama", inflection_class: 1, options: { extension: "n" }}]
+        shp(args).parse.should =~ [{type: :ppa, stem: "ama", inflection_class: 1, options: { extension: "n" }}]
+      end
+
+      it "changes type to ppa with options modus: 'participle'" do
+        args = [{type: :praesens, stem: "ama", inflection_class: 1, options: { modus: :participium }}]
+        shp(args).parse.should =~ [{type: :ppa, stem: "ama", inflection_class: 1, options: { modus: :part }}]
+      end
+
+      it "changes type to ppa with options modus: 'infinitive'" do
+        args = [{type: :praesens, stem: "ama", inflection_class: 1, options: { modus: :infinitive }}]
+        shp(args).parse.should =~ [{type: :praesens_infinitivum, stem: "ama", inflection_class: 1, options: { modus: :inf }}]
+      end
+
+      it "returns hashes of the types praesens praesens_infinitivum ppa gerund gerundive without options" do
+        args = [{type: :praesens, stem: "ama", inflection_class: 1}]
+        shp(args).parse.map { |h| h[:type] }.should =~ %i{ praesens praesens_infinitivum ppa gerund gerundive }
+      end
+
+      context "confronted with irregulars" do
+        it "returns irregular prasens and no verbal nouns for esse" do
+          args = [{type: :praesens, inflection_class: :esse}]
+          shp(args).parse.map { |h| h[:type] }.should =~ %i{ irregular_praesens irregular_praesens_infinitivum }
+        end
+
+        it "returns irregular prasens and no verbal nouns for esse" do
+          opts = {:stem=>"es", :ending=>"se"}
+          args = [{type: :praesens, inflection_class: :esse, options: opts}]
+          shp(args).parse.map { |h| h[:type] }.should =~ %i{ irregular_praesens irregular_praesens_infinitivum }
+        end
+
+
+        it "handles options with ease for irregulars" do
+          opts = { ending: "nt", thematic: "u", stem: "s", prefix: "", extension: "" }
+          args = [{type: :praesens, inflection_class: :esse, options: opts}]
+          shp(args).parse.map { |h| h[:type] }.should =~ %i{ irregular_praesens }
+        end
+
+        it "returns irregular prasens and no verbal nouns for fieri" do
+          args = [{type: :praesens, inflection_class: :fieri}]
+          shp(args).parse.map { |h| h[:type] }.should =~ %i{ irregular_praesens irregular_praesens_infinitivum }
+        end
+
+        it "returns irregular prasens and no verbal nouns for velle" do
+          args = [{type: :praesens, inflection_class: :velle}]
+          shp(args).parse.map { |h| h[:type] }.should =~ %i{ irregular_praesens irregular_praesens_infinitivum }
+        end
+
+        it "returns irregular prasens and no verbal nouns for malle" do
+          args = [{type: :praesens, inflection_class: :malle}]
+          shp(args).parse.map { |h| h[:type] }.should =~ %i{ irregular_praesens irregular_praesens_infinitivum }
+        end
+
+        it "returns irregular prasens and no verbal nouns for edere" do
+          args = [{type: :praesens, inflection_class: :edere}]
+          shp(args).parse.map { |h| h[:type] }.should =~ %i{ irregular_praesens irregular_praesens_infinitivum }
+        end
+
+        it "returns irregular prasens and nouns for ferre" do
+          args = [{type: :praesens, inflection_class: :ferre}]
+          shp(args).parse.map { |h| h[:type] }.should =~ %i{ irregular_praesens irregular_praesens_infinitivum ppa gerund gerundive }
+        end
+
+        it "returns irregular prasens and verbal nouns for ire" do
+          args = [{type: :praesens, inflection_class: :ire}]
+          shp(args).parse.map { |h| h[:type] }.should =~ %i{ irregular_praesens irregular_praesens_infinitivum irregular_ppa irregular_gerund irregular_gerundive }
+        end
+
+        it "returns irregular prasens and no verbal nouns for posse" do
+          args = [{type: :praesens, inflection_class: :posse}]
+          shp(args).parse.map { |h| h[:type] }.should =~ %i{ irregular_praesens irregular_praesens_infinitivum }
+        end
+      end
+    end
+
+    context "with perfectum" do
+      it "changes type to perfectum_infinitivum with options modus: 'infinitive'" do
+        args = [{type: :perfectum, stem: "amav", inflection_class: 1, options: { modus: :infinitive }}]
+        shp(args).parse.should =~ [{type: :perfectum_infinitivum, stem: "amav", inflection_class: 1, options: { modus: :inf }}]
+      end
+
+      it "returns perfectum and perfectum_infinitivum without options" do
+        args = [{type: :perfectum, stem: "amav", inflection_class: 1 }]
+        shp(args).parse.should =~ [{type: :perfectum, stem: "amav", inflection_class: 1},
+                                   {type: :perfectum_infinitivum, stem: "amav", inflection_class: 1}]
+      end
+
+      it "returns perfectum with detailed options like venisset has" do
+        opts = {:ending=>"t", :extension=>"isse", :validate => true}
+        args = [{:type=>:perfectum, :stem=>"ven", :inflection_class=>4, options: opts}]
+        shp(args).parse.should =~ [{type: :perfectum, stem: "ven", inflection_class: 4, options: opts}]
+      end
+    end
+
+    context "with ppp" do
+      it "changes type to fp with options extensions: 'ur'" do
+        args = [{type: :ppp, stem: "amat", inflection_class: 1, options: { extension: "ur" }}]
+        shp(args).parse.should =~ [{type: :fp, stem: "amat", inflection_class: 1, options: { extension: "ur" }}]
+      end
+
+      it "changes type to ... with options modus: 'participle'" do
+        args = [{type: :ppp, stem: "amat", inflection_class: 1, options: { modus: :participium }}]
+        shp(args).parse.should =~ [{type: :ppp, stem: "amat", inflection_class: 1, options: { modus: :part }},
+                                   {type: :fp,  stem: "amat", inflection_class: 1, options: { modus: :part }} ]
+      end
+
+      it "changes type supinum with options modus: 'supinum'" do
+        args = [{type: :ppp, stem: "amat", inflection_class: 1, options: { modus: :supinum }}]
+        shp(args).parse.should =~ [{type: :supinum,  stem: "amat", inflection_class: 1, options: { modus: :supinum } }]
+      end
+
+      it "returns ppp, fp and supinum without options" do
+        args = [{type: :ppp, stem: "amat", inflection_class: 1}]
+        shp(args).parse.should =~ [{type: :ppp, stem: "amat", inflection_class: 1 },
+                                   {type: :fp,  stem: "amat", inflection_class: 1 },
+                                   {type: :supinum,  stem: "amat", inflection_class: 1 }]
+      end
+    end
+
+    context "with adjectives" do
+      it "returns adjective and adverb stems" do
+        args = [{type: :adjective, stem: "alt", inflection_class: 1, comparatio: :positivus}]
+        shp(args).parse.should =~ [ {type: :adjective, stem: "alt", inflection_class: 1, comparatio: :positivus},
+                                    {type: :adverb, stem: "alt", inflection_class: 1, comparatio: :positivus}]
+      end
+
+      it "corrects the comparativus stem" do
+        args = [{type: :adjective, stem: "altior", inflection_class: 1, comparatio: :comparativus}]
+        shp(args).parse.should =~ [ {type: :adjective, stem: "altior", inflection_class: 1, comparatio: :comparativus},
+                                    {type: :adverb, stem: "altius", inflection_class: 1, comparatio: :comparativus}]
+
+      end
+
+      it "returns only adjecive stem when irregular adverb building is present" do
+        args = [{type: :adjective, stem: "bon", inflection_class: 1, comparatio: :positivus, irregular_adverb: true}]
+        shp(args).parse.should =~ [ {type: :adjective, stem: "bon", inflection_class: 1, comparatio: :positivus, irregular_adverb: true} ]
+      end
+    end
+
+    context "with pronouns" do
+      context "with quisque" do
+        it "returns substantivic AND adjectivic stem, when options come with ending is" do
+          args = [{type: :pronoun, inflection_class: :quisque, options: { ending: "is"} }]
+          stems = shp(args).parse
+          stems.should have(2).items
+          stems.map { |st| st[:inflection_class] }.should == %i{ quisque quisque_s  }
+
+          args = [{type: :pronoun, inflection_class: :quisque_s, options: { ending: "is"} }]
+          stems = shp(args).parse
+          stems.should have(2).items
+          stems.map { |st| st[:inflection_class] }.should == %i{ quisque quisque_s  }
+        end
+      end
+    end
+
+    context "with unusquisque" do
+      it "works like quisque" do
+        args = [{type: :pronoun, inflection_class: :unusquisque, options: { ending: "is"} }]
+        stems = shp(args).parse
+        stems.should have(2).items
+        stems.map { |st| st[:inflection_class] }.should == %i{ unusquisque unusquisque_s  }
+
+        args = [{type: :pronoun, inflection_class: :unusquisque_s, options: { ending: "is"} }]
+        stems = shp(args).parse
+        stems.should have(2).items
+      end
+    end
+  end
+end

data/spec/lib/llt/form_builder/irregular_gerund_builder_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe LLT::FormBuilder do
+  describe ".build" do
+    context "with irregular gerundiva" do
+      context "with gerundives" do
+        context "with options that select a specfic form given in a stem" do
+          context "with validate flag" do
+            it "builds correct forms only" do
+              options = { prefix: "ad", ending: "um" }
+              args = [{type: :irregular_gerund, inflection_class: :ferre, options: options}]
+              forms = LLT::FormBuilder.build(*args)
+              forms.should have(1).item
+              forms.first.to_s(:segmentized).should == "ad-fer-e-nd-um"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/lib/llt/form_builder/irregular_gerundive_builder_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe LLT::FormBuilder do
+  describe ".build" do
+    context "with irregular gerundiva" do
+      context "with gerundives" do
+        context "with options that select a specfic form given in a stem" do
+          context "with validate flag" do
+            it "builds correct forms only" do
+              options = { prefix: "ad", ending: "um" }
+              args = [{type: :irregular_gerundive, inflection_class: :ferre, options: options}]
+              forms = LLT::FormBuilder.build(*args)
+              forms.should have(4).items
+              forms.first.to_s(:segmentized).should == "ad-fer-e-nd-um"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/llt/form_builder/irregular_praesens_builder_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe LLT::FormBuilder do
+  describe ".build" do
+    context "with options" do
+      it "builds the form fiebat" do
+        opts = {:stem=>"fi", :thematic=>"e", :extension=>"ba", :ending=>"t", validate: true}
+        args = { type: :praesens, inflection_class: :fieri, options: opts}
+        forms = LLT::FormBuilder.build(args)
+        forms.should have(1).item
+      end
+    end
+  end
+end

data/spec/lib/llt/form_builder/irregular_praesens_infinitivum_builder_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe LLT::FormBuilder do
+  describe ".build" do
+    context "with irregular praesens infinitive" do
+      context "with options" do
+        it "builds the form esse" do
+          opts = {:stem=>"es", :ending=>"se"}
+          args = { type: :praesens, inflection_class: :esse, options: opts}
+          forms = LLT::FormBuilder.build(args)
+          forms.should have(1).item
+        end
+
+        it "builds the form posse" do
+          opts = {:stem=>"pos", :ending=>"se"}
+          args = { type: :praesens, inflection_class: :posse, options: opts}
+          forms = LLT::FormBuilder.build(args)
+          forms.should have(1).item
+        end
+
+        it "builds the form abesse" do
+          opts = {:stem=>"es", :prefix=>"ab", :ending=>"se"}
+          args = { type: :praesens, inflection_class: :esse, options: opts}
+          forms = LLT::FormBuilder.build(args)
+          forms.should have(1).item
+          forms.first.to_s(:segmentized).should == "ab-es-se"
+        end
+      end
+    end
+  end
+end
+