llt-helpers 0.0.4

data/spec/lib/llt/helpers/constantize_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe LLT::Helpers::Constantize do
+  class Dummy
+    include LLT::Helpers::Constantize
+  end
+
+  module LLT
+    class Test; end
+    class TestSuffixed; end
+    class PrefixedTest; end
+    class PrefixedTestSuffixed; end
+    class PrefixUsTestUs; end
+  end
+
+  class Test; end
+
+  module TestModule
+    class NestedTest; end
+  end
+
+  let(:dummy) { Dummy.new }
+
+  describe "#constant_by_type" do
+    it "returns a constant from a given type (as string)" do
+      dummy.constant_by_type("test").should == LLT::Test
+    end
+
+    it "returns a constant from a given type (as symbol)" do
+      dummy.constant_by_type(:test).should == LLT::Test
+    end
+
+    it "can be prefixed" do
+      dummy.constant_by_type(:test, prefix: "prefixed").should == LLT::PrefixedTest
+    end
+
+    it "can be suffixed" do
+      dummy.constant_by_type(:test, suffix: "suffixed").should == LLT::TestSuffixed
+    end
+
+    it "can be prefixed and suffixed" do
+      dummy.constant_by_type(:test, prefix: "prefixed", suffix: "suffixed").should == LLT::PrefixedTestSuffixed
+    end
+
+    it "underscores are handled correctly - test_underscore to TestUnderscore" do
+      dummy.constant_by_type(:test_us, prefix: :prefix_us).should == LLT::PrefixUsTestUs
+    end
+
+    it "namespace defaults to LLT" do
+      dummy.constant_by_type("test").should == LLT::Test
+    end
+
+    it "namespace can be niled to access top level classes" do
+      dummy.constant_by_type("test", namespace: nil).should == Test
+    end
+
+    it "accepts a namespace" do
+      dummy.constant_by_type(:nested_test, namespace: TestModule).should == TestModule::NestedTest
+    end
+
+    it "defaults the type argument to @type when no type is given" do
+      dummy.instance_variable_set("@type", :test)
+      dummy.constant_by_type.should == LLT::Test
+    end
+
+    it "default at @type is returned in its :full form" do
+      module LLT::Adjective; end
+      module LLT::Adj; end
+
+      dummy.instance_variable_set("@type", :adj)
+      dummy.constant_by_type.should == LLT::Adjective
+      dummy.constant_by_type.should_not == LLT::Adj
+    end
+
+    it "throws an error if type is nil" do
+      expect { dummy.constant_by_type(prefix: :test) }.to raise_error
+    end
+  end
+end

data/spec/lib/llt/helpers/equality_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe LLT::Helpers::Equality do
+  class Dummy2
+    extend LLT::Helpers::Equality
+
+    attr_reader :type, :lemma_key, :tempus
+
+    def initialize(type, lemma_key, tempus)
+      @type = type
+      @lemma_key = lemma_key
+      @tempus = tempus
+    end
+  end
+
+  describe ".equality_of_***_defined_by" do
+    it "defines attributes through which equality is identified and adds a method to ask for it" do
+      Dummy2.equality_of_lemma_defined_by :type, :lemma_key
+      d = Dummy2.new(:verb, 1489, :perfectum)
+      d.should respond_to(:equality_definition_for_lemma)
+      d.should respond_to(:same_lemma_as?)
+    end
+  end
+
+  describe "#same_***_as?" do
+    it "checks for equality as defined in the class definition" do
+      Dummy2.equality_of_lemma_defined_by :type, :lemma_key
+      d1 = Dummy2.new(:verb, 1, :perfectum)
+      d2 = Dummy2.new(:verb, 1, :futurum)
+      d3 = Dummy2.new(:verb, 2, :perfectum)
+
+      d1.same_lemma_as?(d2).should be_true
+      d1.same_lemma_as?(d3).should be_false
+    end
+
+    it "works through method missing" do
+      Dummy2.equality_of_form_defined_by :type, :lemma_key, :tempus
+      d1 = Dummy2.new(:verb, 1, :perfectum)
+      d2 = Dummy2.new(:verb, 1, :futurum)
+      d3 = Dummy2.new(:verb, 2, :perfectum)
+      d4 = Dummy2.new(:verb, 1, :perfectum)
+
+      d1.same_form_as?(d2).should be_false
+      d1.same_form_as?(d3).should be_false
+      d1.same_form_as?(d4).should be_true
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe LLT::Helpers::Functions do
+  class Dummy
+    include LLT::Helpers::Functions
+
+    def functions
+      [:a]
+    end
+  end
+
+  let(:dummy) { Dummy.new }
+
+  describe "#has_function?" do
+    it "returns true if argument is included in #functions" do
+      dummy.has_function?(:a).should be_true
+    end
+
+    it "returns false if argument is not included in #functions" do
+      dummy.has_function?(:b).should be_false
+    end
+  end
+
+  describe "#has_f?" do
+    it "is a shortcut for #has_function?" do
+      dummy.has_f?(:a).should be_true
+      dummy.has_f?(:b).should be_false
+    end
+  end
+
+  describe "#has_not_function?" do
+    it "returns false if argument is included in #functions" do
+      dummy.has_not_function?(:a).should be_false
+    end
+
+    it "returns true if argument is not included in #functions" do
+      dummy.has_not_function?(:b).should be_true
+    end
+  end
+
+  describe "#has_not_f?" do
+    it "is a shortcut for #has_not_function?" do
+      dummy.has_not_f?(:a).should be_false
+      dummy.has_not_f?(:b).should be_true
+    end
+  end
+end

data/spec/lib/llt/helpers/initialize_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe LLT::Helpers::Initialize do
+  class Dummy
+    include LLT::Helpers::Initialize
+  end
+
+  let(:dummy) { Dummy.new }
+
+  describe "#extract_args!" do
+    let(:args) { { test1: 1, test2: 2, test3: 3 } }
+
+    context "with two arguments" do
+      it "extracts args given in a hash and maps given keys inside an Array to instance variables" do
+        dummy.extract_args!(args, [:test1, :test2])
+        dummy.instance_variable_get("@test1").should == 1
+        dummy.instance_variable_get("@test2").should == 2
+        dummy.instance_variable_get("@test3").should be_nil
+      end
+    end
+
+    context "with one argument" do
+      it "throws an error when #init_keys is not implemented" do
+        expect { dummy.extract_args!(args) }.to raise_error
+      end
+
+      it "maps the keys given in #init_keys" do
+        class Dummy
+          def init_keys
+            %i{ test1 test2 }
+          end
+        end
+
+        dummy.extract_args!(args)
+        dummy.instance_variable_get("@test1").should == 1
+        dummy.instance_variable_get("@test2").should == 2
+        dummy.instance_variable_get("@test3").should be_nil
+      end
+    end
+  end
+
+  describe "#extract_normalized_args!" do
+    it "extracts args and normalizes them" do
+      class Dummy; def init_keys; %i{ inflection_class }; end; end
+
+      dummy.extract_normalized_args!(itype: 1)
+      dummy.instance_variable_get("@inflection_class").should == 1
+    end
+  end
+end

data/spec/lib/llt/helpers/metrical_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe LLT::Helpers::Metrical do
+  class Dummy
+    include LLT::Helpers::Metrical
+  end
+
+  let(:dummy) { Dummy.new }
+
+  describe "#evaluate_metrical_presence" do
+    it "evaluates if a given string contains metrical utf8 information" do
+      dummy.evaluate_metrical_presence("test").should be_false
+      dummy.evaluate_metrical_presence("tēst").should be_true
+    end
+
+    it "returns false if the given string is actually nil" do
+      dummy.evaluate_metrical_presence(nil).should be_false
+    end
+  end
+
+  describe "#metrical?" do
+    it "defaults to false" do
+      dummy.metrical?.should be_false
+    end
+
+    it "responds accordingly after successful evaluation" do
+      dummy.evaluate_metrical_presence("test")
+      dummy.metrical?.should be_false
+
+      dummy.evaluate_metrical_presence("tēst")
+      dummy.metrical?.should be_true
+    end
+  end
+
+  describe "#wo_meter" do
+    it "strips all quantifying diacritics of a string" do
+      dummy.wo_meter('fēmĭnīs').should == 'feminis'
+    end
+  end
+end

data/spec/lib/llt/helpers/normalizer_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe LLT::Helpers::Normalizer do
+  describe "#normalize_args" do
+    def norm(args)
+      normalizer.normalize_args(args)
+    end
+
+    let(:normalizer) { LLT::Helpers::Normalizer }
+    let(:dummy) { Dummy.new }
+
+    it "can be included as instance method" do
+      class Dummy
+        include LLT::Helpers::Normalizer
+      end
+
+
+      dummy.should respond_to(:normalize_args)
+    end
+
+    it "can be called as module method" do
+      normalizer.should respond_to(:normalize_args)
+    end
+
+    describe "rebuilds an argument hash with LLT::Constants::Terminology" do
+      it "normalizes" do
+        args = { "tense" => "present", case: "acc", numerus: "singular" }
+        norm(args).should == { tempus: :pr, casus: 4, numerus: 1 }
+      end
+
+      it "additionally normalizes the key stem to a symbol, even if there is no key term for it" do
+        args = { 'type' => 'noun', 'stem' => 'exercit', 'iclass' => '4', 'gender' => 'm' }
+        norm(args).should == { type: :noun, stem: 'exercit', inflection_class: 4, sexus: :m }
+      end
+    end
+
+    it "normalizes a nested options hash as well" do
+      args = { tempus: :present, options: { mood: :indicative } }
+      norm(args).should == { tempus: :pr, options: { modus: :ind  } }
+    end
+
+    it "normalizes a nested options hash as well II" do
+      args = { options: { mood: "gerund" } }
+      norm(args).should == { options: { modus: :gerundium } }
+    end
+
+    it "leaves unknown keys intact" do
+      args = { "foo" => "bar" }
+      norm(args).should == args
+    end
+
+    it "leaves pure string values intact (nominative and stem)" do
+      norm(nom: "libido").should == { nom: "libido" }
+      norm(nominative: "libido").should == { nom: "libido" }
+    end
+  end
+end

data/spec/lib/llt/helpers/pluralize_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe LLT::Helpers::Pluralize do
+  class Dummy
+    include LLT::Helpers::Pluralize
+  end
+
+  let(:dummy) { Dummy.new }
+
+  describe "#pluralize" do
+    describe "pluralizes like rails" do
+      context "when count is 1" do
+        it "returns sg" do
+          dummy.pluralize(1, "form").should == "form"
+        end
+      end
+
+      context "when count is 0 or < 1" do
+        context "without pl as param" do
+          it "builds s" do
+            dummy.pluralize(0, "form").should == "forms"
+            dummy.pluralize(2, "form").should == "forms"
+          end
+
+          it "builds y to ies" do
+            dummy.pluralize(2, "entry").should == "entries"
+          end
+        end
+
+        context "with custom pl as param" do
+          it "uses the custom plural" do
+            dummy.pluralize(2, "sg", "whatever").should == "whatever"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/llt/helpers/positions_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe LLT::Helpers::Positions do
+  class P
+    attr_accessor :position
+
+    include LLT::Helpers::Positions
+
+    def initialize(position)
+      @position = position
+    end
+  end
+
+  let(:ab) { [P.new(1), P.new(5)] }
+
+  describe "#===" do
+    it "is true when two objects have the same position" do
+      a = P.new(1)
+      b = P.new(1)
+      c = P.new(2)
+
+      (a === b).should be_true
+      (a === c).should be_false
+    end
+  end
+
+  describe "#<, #>, #>=, #<=, <=>" do
+    it "do as expected in regards to @position" do
+      a = P.new(1)
+      b = P.new(1)
+      c = P.new(2)
+
+      (a < c).should be_true
+      (a <=> b).should be_zero
+    end
+  end
+
+  describe "#surrounding" do
+    it "returns the fixnum value of the position before and after an object" do
+      a = P.new(1)
+      a.surrounding.should == [0, 2]
+    end
+  end
+
+  describe "#distance_to" do
+    it "returns the distance to another object" do
+      a, b = ab
+
+      a.distance_to(b).should == 4
+    end
+
+    it "returns a negative fixnum when the receiver is behind the object passed in as argument" do
+      a, b = ab
+
+      b.distance_to(a).should == -4
+    end
+
+    it "a negative result is absoluted, when a true flag is passed" do
+      a, b = ab
+      b.distance_to(a, true).should == 4
+    end
+  end
+
+  describe "#close_to?" do
+    it "responds to true if objects are positionally close to each other" do
+      a = P.new(1)
+      b = P.new(2)
+
+      a.close_to?(b).should be_true
+      b.close_to?(a).should be_true
+    end
+
+    it "takes a fixnuma argument to declare a range where close is considered to be true" do
+      a, b = ab # 1, 5
+      a.close_to?(b, 3).should be_false
+      a.close_to?(b, 4).should be_true
+      a.close_to?(b, 5).should be_true
+    end
+  end
+
+  describe "#between?" do
+    it "returns true if the receiver is between arguments a and b" do
+      a, b = ab
+      c = P.new(3)
+      d = P.new(6)
+
+      c.between?(a, b).should be_true
+      d.between?(a, b).should be_false
+    end
+  end
+
+  describe "#range_with" do
+    it "returns the positions between the receiver and the passed in object in an array - excludes start and end" do
+      a, b = ab
+      a.range_with(b).should ==  [2, 3, 4]
+    end
+
+    it "results are always sorted" do
+      a, b = ab
+      b.range_with(a).should == a.range_with(b)
+    end
+
+    it "returns a real Range object with a true flag" do
+      a, b = ab
+      a.range_with(b, true).should == (2...5)
+    end
+  end
+end