llt-form_builder 0.0.1

data/lib/llt/stem.rb

@@ -0,0 +1,145 @@
+require 'llt/helpers'
+
+module LLT
+  class Stem
+    include Helpers::Initialize
+    include Helpers::Transformer
+    include Helpers::Normalizer
+
+    files = %w{ noun_stem verb_stem adjective_stem ethnic_stem
+                pack noun_pack verb_pack adjective_pack }
+    files.each do |file|
+      require "llt/stem/#{file}"
+    end
+
+    attr_reader :type, :stem
+
+    def initialize(type, args)
+      @type = t.send(type, :full)
+      extract_normalized_args!(args)
+    end
+  end
+end
+#class Stem
+#  attr_reader :stem, :metrical, :detailed_type
+#
+#  include LLT::Helpers::Initialize
+#  include LLT::Helpers::Transformer
+#
+#  # this should hold inflection type info as well
+#  # subclass for type
+#
+#  def initialize(type, stem, metrical = nil, args)
+#    @type = type
+#    @stem = stem
+#    @metrical = metrical
+#    extract_args!(args)
+#  end
+#
+#  def init_keys
+#    %i{ special_info }
+#  end
+#
+#  def unicode
+#    @stem
+#  end
+#
+#  def to_s
+#    "#{type_info}:\t#{stem} (#{@metrical})\t#{@special_info}"
+#  end
+#  alias :inspect :to_s
+#
+#  def type_info
+#    shortened_type
+#  end
+#
+#  def shortened_type
+#    case @type
+#    when :adverb      then :adv
+#    when :conjunction then :conj
+#    else @type
+#    end
+#  end
+#
+#  def type
+#    @type ||= self.class.name.chomp("Stem").downcase.to_sym
+#  end
+#
+#  def inflectable_class_type
+#    @inflectable_class
+#  end
+#end
+#
+#class ComplexStem < Stem
+#  def init_keys
+#    super + %i{ inflectable_class }
+#  end
+#
+#  def type_info
+#    "#{super} #{inflectable_class_type} #{additional_stem_info}"
+#  end
+#end
+#
+#class VerbStem < ComplexStem
+#  # what happens when a lemma has two different stems? it infl class right, even for perfstems?
+#  def init_keys
+#    super + %i{ tense deponens }
+#  end
+#
+#  def additional_stem_info
+#    @tense
+#  end
+#
+#  def type_info
+#    super + (@deponens ? " #{dep_status}" : "")
+#  end
+#
+#  def dep_status
+#    "dep".green if @deponens
+#  end
+#end
+#
+##class NounStem < ComplexStem
+##  def init_keys
+##    super + %i{ sexus } # nominative?
+##  end
+##
+##  def additional_stem_info
+##    @sexus
+##  end
+##
+##  def inflectable_class_type
+##    case @inflectable_class
+##    when 1  then "A"
+##    when 2  then "O"
+##    when 3  then "C"
+##    when 31 then
+##    when 32 then
+##    when 33 then
+##    when 4  then "U"
+##    when 5  then "E"
+##    end
+##  end
+##end
+#
+#class AdjectiveStem < ComplexStem
+#  def init_keys
+#    super + %i{ number_of_endings }
+#  end
+#
+#  def additional_stem_info
+#    @number_of_endings
+#  end
+#
+#  def shortened_type
+#    :adj
+#  end
+#
+#  def inflectable_class_type
+#    case @inflectable_class
+#    when 1 then "A/O"
+#    when 3 then "Third"
+#    when 5 then "Pronominal"
+#    end
+#  end
+#end

data/lib/llt/stem_builder.rb

@@ -0,0 +1,53 @@
+require 'llt/stem'
+require 'llt/helpers/constantize'
+
+module LLT
+  class StemBuilder
+    extend Helpers::Constantize
+
+    def self.build(type, args, source)
+      type = parse_type_and_extend_args(type, args)
+      pre = complex_stems.include?(type) ? type : ""
+      cl  = constant_by_type(:pack, prefix: pre, namespace: LLT::Stem)
+      cl.new(type, args, source)
+    end
+
+    private
+
+    def self.complex_stems
+      %i{ noun adjective verb }
+    end
+
+    def self.parse_type_and_extend_args(type, args)
+      if type == :persona || type == :place
+        add_to_args(type, args)
+        :noun
+      else
+        type
+      end
+    end
+
+    def self.add_to_args(type, args)
+      args[type] = true
+    end
+
+    def self.pack_factory(args)
+      build(:verb, args, 'llt')
+    end
+
+    # TODO 02.10.13 16:07 by LFDM
+    # Fill in the string values of the various stems
+
+    # edo deliberately left out atm...
+    IRREGULAR_STEMS = {
+      esse:  pack_factory(pr: "e/s/es/er", pf: "fu",              inflection_class: :esse),
+      posse: pack_factory(pr: "pos/pot",   pf: "potu",            inflection_class: :posse),
+      ferre: pack_factory(pr: "fer",       pf: "tul", ppp: "lat", inflection_class: :ferre),
+      fieri: pack_factory(pr: "fi",                               inflection_class: :fieri),
+      ire:   pack_factory(pr: "",          pf: "",    ppp: "",    inflection_class: :ire),
+      velle: pack_factory(pr: "",          pf: "volu",            inflection_class: :velle),
+      nolle: pack_factory(pr: "",          pf: "nolu",            inflection_class: :nolle),
+      malle: pack_factory(pr: "",          pf: "malu",            inflection_class: :malle),
+    }
+  end
+end

data/llt-form_builder.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'llt/form_builder/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "llt-form_builder"
+  spec.version       = LLT::FormBuilder::VERSION
+  spec.authors       = ["LFDM", "lichtr"]
+  spec.email         = ["1986gh@gmail.com", "robert.lichtensteiner@gmail.com"]
+  spec.description   = %q{Builds valid Latin forms of given stems}
+  spec.summary       = %q{#{spec.description}}
+  spec.homepage      = ""
+  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.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov", "~> 0.7"
+  spec.add_development_dependency "blunt_stub_factory"
+  spec.add_development_dependency "yard"
+  spec.add_dependency "llt-constants"
+  spec.add_dependency "llt-core_extensions"
+  spec.add_dependency "llt-helpers"
+end

data/spec/lib/llt/form/adjective_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe LLT::Form::Adjective do
+  let(:adj) { LLT::Form::Adjective.new({}) }
+
+  it "has functions adjective and substantive" do
+    adj.has_f?(:adjective).should be_true
+    adj.has_f?(:substantive).should be_true
+  end
+end

data/spec/lib/llt/form/adverb_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe LLT::Form::Adverb do
+  describe "#string" do
+    it "returns the string value" do
+      adv = LLT::Form::Adverb.new(string: 'semper')
+      adv.string.should == 'semper'
+    end
+  end
+
+  describe "#stem" do
+    it "is an alias for string" do
+      adv = LLT::Form::Adverb.new(string: 'semper')
+      adv.stem.should == 'semper'
+    end
+  end
+end

data/spec/lib/llt/form/conjunction_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe LLT::Form::Conjunction do
+  let(:conj) { LLT::Form::Conjunction.new(string: 'et') }
+
+  describe "#string" do
+    it "returns the string value" do
+      conj.string.should == 'et'
+    end
+  end
+
+  describe "#stem" do
+    it "is an alias to string" do
+      conj.stem.should == 'et'
+    end
+  end
+
+  describe "#lemma" do
+    it "is another alias for string" do
+      conj.lemma.should == 'et'
+    end
+  end
+end

data/spec/lib/llt/form/demonstrative_pronoun_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe LLT::Form::DemonstrativePronoun do
+  let(:dem_pron) { LLT::Form::DemonstrativePronoun.new({}) }
+
+  it "has function demonstrative_pronoun" do
+    dem_pron.has_f?(:demonstrative_pronoun).should be_true
+  end
+
+  it "includes its inflection_class in its functions" do
+    dem_pron.instance_variable_set('@inflection_class', :hic)
+    dem_pron.has_f?(:hic).should be_true
+  end
+end

data/spec/lib/llt/form/fp_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe LLT::Form::Fp do
+  let(:fp) { LLT::Form::Fp.new({}) }
+
+  it "has functions fp, substantive, adjective and participle" do
+    fp.has_f?(:fp).should be_true
+    fp.has_f?(:substantive).should be_true
+    fp.has_f?(:adjective).should be_true
+    fp.has_f?(:participle).should be_true
+  end
+end

data/spec/lib/llt/form/functions_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe LLT::Form::Verb do
+  describe "#init_function" do
+    it "returns the correct initial functions of a verb" do
+      pending
+      options = { ending: "i" }
+      args = [{type: :perfectum, stem: "amav", inflection_class: 1, options: options}]
+      verb = LLT::FormBuilder.build(*args).first
+      verb.init_function.should == [:verb]
+    end
+  end
+end

data/spec/lib/llt/form/gerund_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe LLT::Form::Gerund do
+  let(:gerund) { LLT::Form::Gerund.new({}) }
+
+  it "has functions gerund, substantive" do
+    gerund.has_f?(:gerund).should be_true
+    gerund.has_f?(:substantive).should be_true
+  end
+end

data/spec/lib/llt/form/gerundive_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe LLT::Form::Gerundive do
+  let(:gerundive) { LLT::Form::Gerundive.new({}) }
+
+  it "has function gerundive" do
+    gerundive.has_f?(:gerundive).should be_true
+  end
+
+  it "has function substantive - to play the role of a dominant participle" do
+    gerundive.has_f?(:substantive).should be_true
+  end
+end

data/spec/lib/llt/form/noun_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe LLT::Form::Noun do
+  let(:noun) { LLT::Form::Noun.new({}) }
+
+  it "has functions noun and substantive" do
+    noun.has_f?(:noun).should be_true
+    noun.has_f?(:substantive).should be_true
+  end
+
+  describe "#stems=" do
+    it "sets a noun's stems" do
+      dummy = double
+      noun.stems = dummy
+      noun.stems.should == dummy
+    end
+  end
+end

data/spec/lib/llt/form/ppa_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe LLT::Form::Ppa do
+  let(:ppa) { LLT::Form::Ppa.new({}) }
+
+  it "has functions ppa, substantive, adjective and participle" do
+    ppa.has_f?(:ppa).should be_true
+    ppa.has_f?(:substantive).should be_true
+    ppa.has_f?(:adjective).should be_true
+    ppa.has_f?(:participle).should be_true
+  end
+end

data/spec/lib/llt/form/ppp_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe LLT::Form::Ppp do
+  let(:ppp) { LLT::Form::Ppp.new({}) }
+
+  it "has functions ppp, substantive, adjective and participle" do
+    ppp.has_f?(:ppp).should be_true
+    ppp.has_f?(:substantive).should be_true
+    ppp.has_f?(:adjective).should be_true
+    ppp.has_f?(:participle).should be_true
+  end
+end

data/spec/lib/llt/form/preposition_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe LLT::Form::Preposition do
+  describe "#takes_4th?" do
+    it "returns true if an acc is taken" do
+      args = { string: 'super', takes_4th: true, takes_6th: false }
+      prep = LLT::Form::Preposition.new(args)
+      prep.takes_4th?.should be_true
+    end
+  end
+
+  describe "#takes_6th?" do
+    it "returns true if an abl is taken" do
+      args = { string: 'ex', takes_4th: false, takes_6th: true }
+      prep = LLT::Form::Preposition.new(args)
+      prep.takes_6th?.should be_true
+    end
+  end
+
+  describe "#string" do
+    it "returns the string value" do
+      args = { string: 'ex', takes_4th: false, takes_6th: true }
+      prep = LLT::Form::Preposition.new(args)
+      prep.string.should == 'ex'
+    end
+  end
+
+  describe "#stem" do
+    it "is an alias for string" do
+      args = { string: 'ex', takes_4th: false, takes_6th: true }
+      prep = LLT::Form::Preposition.new(args)
+      prep.stem.should == 'ex'
+    end
+  end
+
+  describe "#lemma" do
+    it "is another alias for string" do
+      args = { string: 'ex', takes_4th: false, takes_6th: true }
+      prep = LLT::Form::Preposition.new(args)
+      prep.lemma.should == 'ex'
+    end
+  end
+end

data/spec/lib/llt/form/supinum_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe LLT::Form::Supinum do
+  let(:supinum) { LLT::Form::Supinum.new({}) }
+
+  it "has function supinum" do
+    supinum.has_f?(:supinum).should be_true
+  end
+end

data/spec/lib/llt/form/verb_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe LLT::Form::Verb do
+  let(:verb) { LLT::Form::Verb.new({}) }
+
+  it "has function verb" do
+    verb.has_f?(:verb)
+  end
+
+  it "has a function named after its conjugation with irregular verbs" do
+    verb.instance_variable_set('@inflection_class', :esse)
+    verb.has_f?(:esse).should be_true
+  end
+end

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

@@ -0,0 +1,182 @@
+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
+
+    def with_adjective(options)
+      args = [{type: :adjective, nominative: "atrox", stem: "atroc", inflection_class: 3,
+        number_of_endings: 1, comparatio: :positivus, options: options}]
+      LLT::FormBuilder.build(*args)
+    end
+
+    context "with adjectives" do
+      context "without options" do
+        it "builds all forms of A/O" do
+          args = [{type: :adjective, stem: "amic", inflection_class: 1, number_of_endings: 3, comparatio: :positivus}]
+          form_builder_strings(args).should == %w{amicus amici amico amicum amice amico amici amicorum amicis amicos amici amicis
+                                                  amica amicae amicae amicam amica amica amicae amicarum amicis amicas amicae amicis
+                                                  amicum amici amico amicum amicum amico amica amicorum amicis amica amica amicis
+                                                  amice}
+        end
+
+        it "gets casus, numerus and sexus right" do
+          args = [{type: :adjective, stem: "amic", inflection_class: 1, number_of_endings: 3, comparatio: :positivus}]
+          forms = LLT::FormBuilder.build(*args)
+          amicus  = forms[ 0]
+          amico   = forms[ 5]
+          amicam  = forms[15]
+          amica_n = forms[30]
+
+          amicus.casus.should == 1
+          amicus.numerus.should == 1
+          amicus.sexus.should == :m
+
+          amico.casus.should == 6
+          amico.numerus.should == 1
+          amico.sexus.should == :m
+
+          amicam.casus.should == 4
+          amicam.numerus.should == 1
+          amicam.sexus.should == :f
+
+          amica_n.casus.should == 1
+          amica_n.numerus.should == 2
+          amica_n.sexus.should == :n
+        end
+
+        it "builds all forms of A/O like pulcher" do
+          args = [{type: :adjective, nominative: "pulcher", stem: "pulchr", inflection_class: 1, number_of_endings: 3, comparatio: :positivus}]
+          form_builder_strings(args).should ==%w{pulcher pulchri pulchro pulchrum pulcher pulchro pulchri pulchrorum pulchris pulchros pulchri pulchris
+                                                 pulchra pulchrae pulchrae pulchram pulchra pulchra pulchrae pulchrarum pulchris pulchras pulchrae pulchris
+                                                 pulchrum pulchri pulchro pulchrum pulchrum pulchro pulchra pulchrorum pulchris pulchra pulchra pulchris
+                                                 pulchre}
+        end
+
+        it "builds all forms of Third with 1 endings" do
+          args = [{type: :adjective, nominative: "atrox", stem: "atroc", inflection_class: 3, number_of_endings: 1, comparatio: :positivus}]
+          form_builder_strings(args).should == %w{atrox atrocis atroci atrocem atrox atroci atroces atrocium atrocibus atroces atroces atrocibus
+                                                  atrox atrocis atroci atrocem atrox atroci atroces atrocium atrocibus atroces atroces atrocibus
+                                                  atrox atrocis atroci atrox atrox atroci atrocia atrocium atrocibus atrocia atrocia atrocibus
+                                                  atrociter}
+        end
+
+        it "builds all forms of Third with 2 endings" do
+          args = [{type: :adjective, nominative: "facilis", stem: "facil", inflection_class: 3, number_of_endings: 2, comparatio: :positivus}]
+          form_builder_strings(args).should == %w{facilis facilis facili facilem facilis facili faciles facilium facilibus faciles faciles facilibus
+                                                  facilis facilis facili facilem facilis facili faciles facilium facilibus faciles faciles facilibus
+                                                  facile facilis facili facile facile facili facilia facilium facilibus facilia facilia facilibus
+                                                  facile}
+        end
+
+        it "builds all forms of Third with 3 endings" do
+          args = [{type: :adjective, nominative: "celer", stem: "celer", inflection_class: 3, number_of_endings: 3, comparatio: :positivus}]
+          form_builder_strings(args).should == %w{celer celeris celeri celerem celer celeri celeres celerium celeribus celeres celeres celeribus
+                                                  celeris celeris celeri celerem celeris celeri celeres celerium celeribus celeres celeres celeribus
+                                                  celere celeris celeri celere celere celeri celeria celerium celeribus celeria celeria celeribus
+                                                  celeriter}
+        end
+
+        it "builds all forms of Pronominal" do
+          args = [{type: :adjective, nominative: "totus", stem: "tot", inflection_class: 5, number_of_endings: 3, comparatio: :positivus}]
+          form_builder_strings(args).should == %w{totus totius toti totum tote toto toti totorum totis totos toti totis
+                                                  tota totius toti totam tota tota totae totarum totis totas totae totis
+                                                  totum totius toti totum totum toto tota totorum totis tota tota totis
+                                                  tote} # is tote even a form?
+        end
+
+        it "builds all forms of comparativus stems" do
+          args = [{type: :adjective, stem: "altior", inflection_class: 1, number_of_endings: 3, comparatio: :comparativus}]
+          form_builder_strings(args).should == %w{altior altioris altiori altiorem altior altiore altiores altiorum altioribus altiores altiores altioribus
+                                                  altior altioris altiori altiorem altior altiore altiores altiorum altioribus altiores altiores altioribus
+                                                  altius altioris altiori altius altius altiore altiora altiorum altioribus altiora altiora altioribus
+                                                  altius}
+        end
+
+        it "knows the comparison sign for comparatives" do
+          args = [{type: :adjective, stem: "altior", inflection_class: 1, number_of_endings: 3, comparatio: :comparativus}]
+          forms = LLT::FormBuilder.build(*args)
+          altioris = forms[1]
+          altioris.comparison_sign.should == "ior"
+        end
+
+        it "buids all forms of superlativus stems" do
+          args = [{type: :adjective, stem: "altissim", inflection_class: 1, number_of_endings: 3, comparatio: :superlativus}]
+          form_builder_strings(args).should == %w{altissimus altissimi altissimo altissimum altissime altissimo altissimi altissimorum altissimis altissimos altissimi altissimis
+                                                  altissima altissimae altissimae altissimam altissima altissima altissimae altissimarum altissimis altissimas altissimae altissimis
+                                                  altissimum altissimi altissimo altissimum altissimum altissimo altissima altissimorum altissimis altissima altissima altissimis
+                                                  altissime}
+        end
+
+        it "knows the comparison sign for superlatives" do
+          args = [{type: :adjective, stem: "altissim", inflection_class: 1, number_of_endings: 3, comparatio: :superlativus}]
+          forms = LLT::FormBuilder.build(*args)
+          altissimi = forms[1]
+          altissimi.comparison_sign.should == "issim"
+        end
+
+        it "handles metrical stems" do
+          args = [{type: :adjective, stem: "altīssīm", inflection_class: 1, number_of_endings: 3, comparatio: :superlativus}]
+          forms = LLT::FormBuilder.build(*args)
+          altissimi = forms[1]
+          altissimi.comparison_sign.should == "īssīm"
+        end
+      end
+
+      context "with options that select a specfic form given in a stem" do
+        it "returns only forms specified in options" do
+          options = { sexus: :f }
+          res = with_adjective(options)
+          res.should have(12).items
+        end
+      end
+
+      context "with options that indicate the word's components" do
+        it "builds correct forms only (several possibilities)" do
+          res  = with_adjective(ending: "is")
+          res2 = with_adjective(ending: "ibus")
+          res .should have(3).items
+          res2.should have(6).items
+        end
+
+        it "builds correct forms only with nominative" do
+          res  = with_adjective(ending: "")
+          res.should have(7).items
+        end
+
+        it "doesn't build incorrect forms" do
+          res = with_adjective(ending: "orum")
+          res.should be_empty
+        end
+
+        it "builds correct forms of improviso" do
+          opts = { ending: "o", validate: true }
+          args = {type: :adjective, stem: "improvis", nom: "improvisus", inflection_class: 1, noe: 3, comparatio: :positivus, options: opts}
+          LLT::FormBuilder.build(args).should have(4).item
+        end
+
+        it "builds correct forms of noster" do
+          opts = { ending: "", validate: true }
+          args = { type: :adjective, stem: "nostr", nom: "noster", inflection_class: 1, noe: 3, comparatio: :positivus, options: opts}
+          forms = LLT::FormBuilder.build(args)
+          forms.should have(2).items
+          nom, voc = forms
+          nom.casus.should == 1
+          voc.casus.should == 5
+        end
+
+        it "builds correct forms of laete (vocative and adverb)" do
+          opts = { ending: "e", validate: true }
+          args = { type: :adjective, nom: "laetus", stem: "laet", inflection_class: 1, number_of_endings: 3, options: opts }
+          forms = LLT::FormBuilder.build(args)
+          forms.should have(2).items
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe LLT::FormBuilder do
+  describe ".build" do
+    it "builds the correct adverb form - positivus" do
+      args = { type: :adverb, comparatio: :positivus, stem: "alt", inflection_class: 1 }
+      forms = LLT::FormBuilder.build(args)
+      forms.should have(1).item
+      forms.first.to_s(:segmentized).should == "alt-e"
+    end
+
+    it "builds the correct adverb form - comparativus" do
+      args = { type: :adverb, comparatio: :comparativus, stem: "altius", inflection_class: 1 }
+      forms = LLT::FormBuilder.build(args)
+      forms.should have(1).item
+      forms.first.to_s(:segmentized).should == "alt-ius"
+    end
+
+    it "builds the correct adverb form - superlativus" do
+      args = { type: :adverb, comparatio: :superlativus, stem: "altissim", inflection_class: 1 }
+      forms = LLT::FormBuilder.build(args)
+      forms.should have(1).item
+      forms.first.to_s(:segmentized).should == "alt-issim-e"
+    end
+  end
+
+end