LittleWeasel 3.0.0 → 4.0.0

data/spec/lib/LittleWeasel/modules/locale_spec.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Modules::Locale, type: :module do
+  Locale = described_class
+
+  subject do
+    Class.new do
+      include Locale
+
+      attr_reader :language, :region
+
+      def initialize(language, region)
+        self.language = language
+        self.region = region
+      end
+
+      private
+
+      attr_writer :language, :region
+    end.new(language, region)
+  end
+
+  let(:language) {}
+  let(:region) {}
+
+  #.locale
+  describe '.locale' do
+    it 'adds the class method when included' do
+      expect(subject.class).to respond_to(:locale)
+    end
+
+    context 'with valid arguments' do
+      let(:language) { :en }
+      let(:region) { :us }
+
+      it 'returns the locale as a string' do
+        expect(subject.class.locale language: language, region: region).to eq 'en-US'
+      end
+    end
+
+    context 'with INVALID arguments' do
+      context 'with an invalid language' do
+        let(:language) {}
+        let(:region) { :us }
+
+        it 'raises an error' do
+          expect { subject.class.locale language: language, region: region }.to raise_error 'Argument language does not respond to :downcase'
+        end
+      end
+
+      context 'when region is nil' do
+        let(:language) { :en }
+        let(:region) {}
+
+        it 'returns the expected locale as a string' do
+          expect(subject.class.locale language: language, region: region).to eq language.downcase.to_s
+        end
+      end
+
+      context 'when region is invalid' do
+        let(:language) { :en }
+        let(:region) { 1 }
+
+        it 'raises an error' do
+          expect { subject.class.locale language: language, region: region }.to raise_error 'Argument region does not respond to :upcase'
+        end
+      end
+    end
+  end
+
+  #locale
+  describe '#locale' do
+    context 'with valid arguments' do
+      context 'with valid language' do
+        let(:language) { :en }
+
+        it 'returns the expected locale (language only)' do
+          expect(subject.locale).to eq 'en'
+        end
+      end
+
+      context 'with valid language and region' do
+        let(:language) { :en }
+        let(:region) { :us }
+
+        it 'returns the expected locale (language and region)' do
+          expect(subject.locale).to eq 'en-US'
+        end
+
+        describe 'normalizes language and region to the proper case' do
+          let(:language) { :EN }
+          let(:region) { :us }
+
+          it 'returns the expected locale with language lowercase and region uppercase' do
+            expect(subject.locale).to eq 'en-US'
+          end
+        end
+      end
+
+      context 'with valid language and nil region' do
+        let(:language) { :en }
+        let(:region) {}
+
+        it 'returns the expected locale (language only)' do
+          expect(subject.locale).to eq 'en'
+        end
+      end
+
+      context 'with valid language and blank region' do
+        let(:language) { :en }
+        let(:region) { '' }
+
+        it 'returns the expected locale (language only)' do
+          expect(subject.locale).to eq 'en'
+        end
+      end
+    end
+
+    context 'with invalid arguments' do
+      context 'with invalid language' do
+        let(:language) { 1 }
+
+        it 'raises an error' do
+          expect { subject.locale }.to raise_error 'Argument language does not respond to :downcase'
+        end
+      end
+
+      context 'with invalid region' do
+        let(:language) { :en }
+        let(:region) { 1 }
+
+        it 'raises an error' do
+          expect { subject.locale }.to raise_error 'Argument region does not respond to :upcase'
+        end
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/modules/region_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Modules::Region, type: :module do
+  Region = described_class
+
+  subject do
+    Class.new do
+      include Region
+
+      attr_reader :region
+
+      def initialize(region)
+        self.region = region
+      end
+
+      private
+
+      attr_writer :region
+    end.new(region)
+  end
+
+  let(:region) {}
+
+  #normalize_region
+  describe '#normalize_region' do
+    context 'with a non-nil region' do
+      context 'when passing a Symbol' do
+        let(:region) { :AbCdEfG }
+
+        it 'converts the region to a upper-case Symbol' do
+          expect(subject.normalize_region).to eq :ABCDEFG
+        end
+      end
+
+      context 'when passing a String' do
+        let(:region) { 'AbCdEfG' }
+
+        it 'converts the region to a upper-case String' do
+          expect(subject.normalize_region).to eq 'ABCDEFG'
+        end
+      end
+    end
+
+    context 'with a nil region' do
+      it 'returns nil' do
+        expect(subject.normalize_region).to be_nil
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/preprocessors/en_us/capitalize_preprocessor_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literals: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Preprocessors::EnUs::CapitalizePreprocessor do
+  subject { described_class.new }
+
+  #.new
+  describe '.new' do
+    it 'instantiates the object' do
+      expect { subject }.to_not raise_error
+    end
+
+    describe '#order' do
+      it 'sets #order to 0 by default' do
+        expect(subject.order).to eq 0
+      end
+    end
+
+    describe '#preprocessor_on' do
+      it 'sets #preprocessor_on to true by default' do
+        expect(subject.preprocessor_on).to eq true
+      end
+    end
+  end
+
+  #.preprocess
+  describe '.preprocess' do
+    it 'processes and capitalizes the word' do
+      expect(described_class.preprocess 'wOrD').to eq [true, 'Word']
+      expect(described_class.preprocess 'Word').to eq [true, 'Word']
+    end
+  end
+end

data/spec/lib/LittleWeasel/preprocessors/preprocessed_word_spec.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Preprocessors::PreprocessedWord do
+  subject do
+    described_class.new(
+      original_word: original_word,
+      preprocessed_word: preprocessed_word,
+      preprocessor: preprocessor,
+      preprocessed: preprocessed,
+      preprocessor_order: preprocessor_order
+    )
+  end
+
+  let(:original_word) { :original_word }
+  let(:preprocessed_word) { :preprocessed_word }
+  let(:preprocessor) { :preprocessor }
+  let(:preprocessed) { true }
+  let(:preprocessor_order) { :preprocessor_order }
+
+  #.new
+  describe '.new' do
+    context 'initializes the attributes' do
+      describe '#original_word' do
+        it 'is initialized' do
+          expect(subject.original_word).to eq :original_word
+        end
+      end
+
+      describe '#preprocessed_word' do
+        it 'is initialized' do
+          expect(subject.preprocessed_word).to eq :preprocessed_word
+        end
+      end
+
+      describe '#preprocessor' do
+        it 'is initialized' do
+          expect(subject.preprocessor).to eq :preprocessor
+        end
+      end
+
+      describe '#preprocessor_order' do
+        it 'is initialized' do
+          expect(subject.preprocessor_order).to eq :preprocessor_order
+        end
+      end
+    end
+  end
+
+  # attributes
+  context 'attributes' do
+    describe 'original_word=' do
+      let(:changed_to) { :original_word_changed }
+
+      it 'sets the attribute' do
+        subject.original_word = changed_to
+        expect(subject.original_word).to eq changed_to
+      end
+    end
+
+    describe 'preprocessed_word=' do
+      let(:changed_to) { :preprocessed_word_changed }
+
+      it 'sets the attribute' do
+        subject.preprocessed_word = changed_to
+        expect(subject.preprocessed_word).to eq changed_to
+      end
+    end
+
+    describe 'preprocessor=' do
+      let(:changed_to) { :preprocessor_changed }
+
+      it 'sets the attribute' do
+        subject.preprocessor = changed_to
+        expect(subject.preprocessor).to eq changed_to
+      end
+    end
+
+    describe 'preprocessor_order=' do
+      let(:changed_to) { :preprocessor_order_changed }
+
+      it 'sets the attribute' do
+        subject.preprocessor_order = changed_to
+        expect(subject.preprocessor_order).to eq changed_to
+      end
+    end
+
+    describe '#preprocessed?' do
+      context 'when preprocessed is true' do
+        it 'returns true' do
+          expect(subject.preprocessed?).to eq true
+        end
+      end
+
+      context 'when preprocessed is false' do
+        let(:preprocessed) { false }
+
+        it 'returns false' do
+          expect(subject.preprocessed?).to eq false
+        end
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/preprocessors/preprocessed_word_validatable_spec.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Preprocessors::PreprocessedWordValidatable, type: :module do
+  PreprocessedWordValidatable = described_class
+
+  class MockSubject
+    include PreprocessedWordValidatable
+  end
+
+  subject do
+    MockSubject.new
+  end
+
+  before do
+    allow(preprocessed_word_object).to receive(:respond_to?).and_call_original
+  end
+
+  let(:preprocessed_word_object) do
+    create(:preprocessed_word,
+      original_word: original_word,
+      preprocessed: preprocessed,
+      preprocessed_word: preprocessed_word,
+      preprocessor: preprocessor,
+      preprocessor_order: preprocessor_order)
+  end
+  let(:original_word) { 'word' }
+  let(:preprocessed) { true }
+  let(:preprocessed_word) { 'preprocessed-word0'}
+  let(:preprocessor) { :preprocesor0 }
+  let(:preprocessor_order) { 0 }
+
+  #.validate_prepreprocessed_word
+  describe '.validate_prepreprocessed_word' do
+    context 'when the object is valid' do
+      it 'does not raise an error' do
+        expect { PreprocessedWordValidatable.validate_prepreprocessed_word(preprocessed_word: preprocessed_word_object) }.to_not raise_error
+      end
+    end
+
+    context 'when the object is INVALID' do
+      context 'when #original_word is missing' do
+        before { allow(preprocessed_word_object).to receive(:respond_to?).with(method).and_return(false) }
+        let(:method) { :original_word }
+
+        it 'raises an eror' do
+          expect { PreprocessedWordValidatable.validate_prepreprocessed_word(preprocessed_word: preprocessed_word_object) }.to raise_error(/Argument preprocessed_word: does not respond to.+#{method}/)
+        end
+      end
+
+      context 'when #original_word= is missing' do
+        before { allow(preprocessed_word_object).to receive(:respond_to?).with(method).and_return(false) }
+        let(:method) { :original_word= }
+
+        it 'raises an eror' do
+          expect { PreprocessedWordValidatable.validate_prepreprocessed_word(preprocessed_word: preprocessed_word_object) }.to raise_error(/Argument preprocessed_word: does not respond to.+#{method}/)
+        end
+      end
+
+      context 'when #preprocessed_word is missing' do
+        before { allow(preprocessed_word_object).to receive(:respond_to?).with(method).and_return(false) }
+        let(:method) { :preprocessed_word }
+
+        it 'raises an eror' do
+          expect { PreprocessedWordValidatable.validate_prepreprocessed_word(preprocessed_word: preprocessed_word_object) }.to raise_error(/Argument preprocessed_word: does not respond to.+#{method}/)
+        end
+      end
+
+      context 'when #preprocessed_word= is missing' do
+        before { allow(preprocessed_word_object).to receive(:respond_to?).with(method).and_return(false) }
+        let(:method) { :preprocessed_word= }
+
+        it 'raises an eror' do
+          expect { PreprocessedWordValidatable.validate_prepreprocessed_word(preprocessed_word: preprocessed_word_object) }.to raise_error(/Argument preprocessed_word: does not respond to.+#{method}/)
+        end
+      end
+
+      context 'when #preprocessed is missing' do
+        before { allow(preprocessed_word_object).to receive(:respond_to?).with(method).and_return(false) }
+        let(:method) { :preprocessed }
+
+        it 'raises an eror' do
+          expect { PreprocessedWordValidatable.validate_prepreprocessed_word(preprocessed_word: preprocessed_word_object) }.to raise_error(/Argument preprocessed_word: does not respond to.+#{method}/)
+        end
+      end
+
+      context 'when #preprocessed= is missing' do
+        before { allow(preprocessed_word_object).to receive(:respond_to?).with(method).and_return(false) }
+        let(:method) { :preprocessed= }
+
+        it 'raises an eror' do
+          expect { PreprocessedWordValidatable.validate_prepreprocessed_word(preprocessed_word: preprocessed_word_object) }.to raise_error(/Argument preprocessed_word: does not respond to.+#{method}/)
+        end
+      end
+
+      context 'when #preprocessed? is missing' do
+        before { allow(preprocessed_word_object).to receive(:respond_to?).with(method).and_return(false) }
+        let(:method) { :preprocessed? }
+
+        it 'raises an eror' do
+          expect { PreprocessedWordValidatable.validate_prepreprocessed_word(preprocessed_word: preprocessed_word_object) }.to raise_error(/Argument preprocessed_word: does not respond to.+#{method}/)
+        end
+      end
+
+      context 'when #preprocessor is missing' do
+        before { allow(preprocessed_word_object).to receive(:respond_to?).with(method).and_return(false) }
+        let(:method) { :preprocessor }
+
+        it 'raises an eror' do
+          expect { PreprocessedWordValidatable.validate_prepreprocessed_word(preprocessed_word: preprocessed_word_object) }.to raise_error(/Argument preprocessed_word: does not respond to.+#{method}/)
+        end
+      end
+
+      context 'when #preprocessor= is missing' do
+        before { allow(preprocessed_word_object).to receive(:respond_to?).with(method).and_return(false) }
+        let(:method) { :preprocessor= }
+
+        it 'raises an eror' do
+          expect { PreprocessedWordValidatable.validate_prepreprocessed_word(preprocessed_word: preprocessed_word_object) }.to raise_error(/Argument preprocessed_word: does not respond to.+#{method}/)
+        end
+      end
+
+      context 'when #preprocessor_order is missing' do
+        before { allow(preprocessed_word_object).to receive(:respond_to?).with(method).and_return(false) }
+        let(:method) { :preprocessor_order }
+
+        it 'raises an eror' do
+          expect { PreprocessedWordValidatable.validate_prepreprocessed_word(preprocessed_word: preprocessed_word_object) }.to raise_error(/Argument preprocessed_word: does not respond to.+#{method}/)
+        end
+      end
+
+      context 'when #preprocessor_order= is missing' do
+        before { allow(preprocessed_word_object).to receive(:respond_to?).with(method).and_return(false) }
+        let(:method) { :preprocessor_order= }
+
+        it 'raises an eror' do
+          expect { PreprocessedWordValidatable.validate_prepreprocessed_word(preprocessed_word: preprocessed_word_object) }.to raise_error(/Argument preprocessed_word: does not respond to.+#{method}/)
+        end
+      end
+    end
+  end
+end