LittleWeasel 3.0.4 → 5.0.1

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

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Preprocessors::PreprocessedWords, type: :module do
+  subject { create(:preprocessed_words, original_word: original_word, preprocessed_words: preprocessed_words) }
+
+  let(:original_word) { 'word' }
+  let(:preprocessed_words) {}
+
+  #.new
+  describe '.new' do
+    it 'instantiates an object' do
+      expect { subject }.to_not raise_error
+    end
+
+    context 'arguments' do
+      context '#original_word' do
+        it 'sets the original_word attribute' do
+          expect(subject.original_word).to eq original_word
+        end
+      end
+
+      context '#preprocessed_words' do
+        let(:preprocessed_words) { [:preprocessed_words] }
+
+        it 'sets the original_word attribute' do
+          expect(subject.preprocessed_words).to eq preprocessed_words
+        end
+      end
+    end
+  end
+
+  #preprocessed_word
+  describe '#preprocessed_word' do
+    subject do
+      create(:preprocessed_words,
+        with_word_processors: 3,
+        original_word: original_word,
+        preprocessed_words: preprocessed_words)
+    end
+
+    it 'returns the preprocessed word' do
+      expect(subject.preprocessed_word).to eq 'word-0-1-2'
+    end
+  end
+
+   #preprocessed?
+  describe '#preprocessed?' do
+    context 'when the word has been preprocessed' do
+      subject do
+        create(:preprocessed_words,
+          with_word_processors: 1,
+          original_word: original_word,
+          preprocessed_words: preprocessed_words)
+      end
+
+      it 'returns the preprocessed word' do
+        expect(subject.preprocessed?).to eq true
+      end
+    end
+
+    context 'when the word has NOT been preprocessed' do
+      subject do
+        create(:preprocessed_words,
+          original_word: original_word,
+          preprocessed_words: preprocessed_words)
+      end
+
+      it 'returns the preprocessed word' do
+        expect(subject.preprocessed?).to eq false
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Preprocessors::PreprocessedWordsValidatable, type: :module do
+  PreprocessedWordsValidatable = described_class
+
+  class MockSubject
+    include PreprocessedWordsValidatable
+  end
+
+  subject do
+    MockSubject.new
+  end
+
+  before do
+    allow(preprocessed_words).to receive(:respond_to?).and_call_original
+  end
+
+  let(:preprocessed_words) do
+    create(:preprocessed_words,
+      original_word: original_word,
+      with_word_processors: with_word_processors)
+  end
+  let(:original_word) { 'word' }
+  let(:with_word_processors) { 0 }
+
+  #.validate_prepreprocessed_words
+  describe '.validate_prepreprocessed_words' do
+    context 'when the object is valid' do
+      it 'does not raise an error' do
+        expect { PreprocessedWordsValidatable.validate_prepreprocessed_words(preprocessed_words: preprocessed_words) }.to_not raise_error
+      end
+    end
+
+    context 'when the object is INVALID' do
+      let(:expected_error) { /Argument preprocessed_words does not respond to:.+##{method}/ }
+
+      context 'when the object does not respond to #original_word' do
+        before { allow(preprocessed_words).to receive(:respond_to?).with(method).and_return(false) }
+        let(:method) { :original_word }
+
+        it 'raises an error' do
+          expect{ PreprocessedWordsValidatable.validate_prepreprocessed_words(preprocessed_words: preprocessed_words) }.to raise_error expected_error
+        end
+      end
+
+      context 'when the object does not respond to #preprocessed_words' do
+        before { allow(preprocessed_words).to receive(:respond_to?).with(method).and_return(false) }
+        let(:method) { :preprocessed_words }
+
+        it 'raises an error' do
+          expect{ PreprocessedWordsValidatable.validate_prepreprocessed_words(preprocessed_words: preprocessed_words) }.to raise_error expected_error
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Preprocessors::WordPreprocessorManagable, type: :module do
+  subject { MockSubject.new }
+
+  WordPreprocessorManagable = described_class
+
+  class MockSubject
+    include WordPreprocessorManagable
+  end
+
+  class MockWordPreprocessor01 < LittleWeasel::Preprocessors::WordPreprocessor
+    def initialize(order: 0)
+      super order: order
+    end
+
+    class << self
+      def preprocess(word) [true, "#{word}-0"]; end
+    end
+  end
+
+  class MockWordPreprocessor02 < MockWordPreprocessor01
+    def initialize
+      super order: 1
+    end
+
+    class << self
+      def preprocess(word) [true, "#{word}-1"]; end
+    end
+  end
+
+  class MockWordPreprocessor03 < MockWordPreprocessor01
+    def initialize
+      super order: 2
+    end
+
+    class << self
+      def preprocess(word) [true, "#{word}-2"]; end
+    end
+  end
+
+  let(:word_preprocessors_01_thru_03) do
+    [MockWordPreprocessor03.new,
+      MockWordPreprocessor02.new,
+      MockWordPreprocessor01.new]
+  end
+
+  class MockWordPreprocessor04 < MockWordPreprocessor01
+    def initialize
+      super order: 3
+    end
+
+    class << self
+      def preprocess(word) [true, "#{word}-3"]; end
+    end
+  end
+
+  class MockWordPreprocessor05 < MockWordPreprocessor01
+    def initialize
+      super order: 4
+    end
+
+    class << self
+      def preprocess(word) [true, "#{word}-4"]; end
+    end
+  end
+
+  class MockWordPreprocessor06 < MockWordPreprocessor01
+    def initialize
+      super order: 5
+    end
+
+    class << self
+      def preprocess(word) [true, "#{word}-5"]; end
+    end
+  end
+
+  let(:word_preprocessors_04_thru_06) do
+    [MockWordPreprocessor06.new,
+      MockWordPreprocessor05.new,
+      MockWordPreprocessor04.new]
+  end
+
+  #preprocessed_word
+  describe '#preprocessed_word' do
+    context 'when word is blank' do
+      it 'returns nil' do
+        expect(subject.preprocessed_word word: 'word').to be_nil
+      end
+    end
+
+    context 'when word is not a String' do
+      it 'returns nil' do
+        expect(subject.preprocessed_word word: :not_a_word).to be_nil
+      end
+    end
+
+    context 'when word is NOT blank' do
+      before do
+        subject.replace_preprocessors word_preprocessors: word_preprocessors_01_thru_03
+      end
+
+      it 'returns the preprocessed word' do
+        expect(subject.preprocessed_word word: 'word').to eq 'word-0-1-2'
+      end
+    end
+  end
+
+  #word_preprocessors
+  describe '#word_preprocessors' do
+    it 'returns an empty Array ([]) by default' do
+      expect(subject.word_preprocessors).to eq []
+    end
+  end
+
+  #clear_preprocessors
+  describe '#clear_preprocessors' do
+    before do
+      subject.replace_preprocessors word_preprocessors: word_preprocessors_01_thru_03
+    end
+
+    it 'clears #word_preprocessors' do
+      expect { subject.clear_preprocessors }.to change { subject.word_preprocessors.count }.from(3).to(0)
+    end
+  end
+
+  #add_preprocessors
+  describe '#add_preprocessors' do
+    context 'when passing an INVALID argument' do
+      context 'when passing an Array of invalid word preprocessors' do
+        it 'raises an error' do
+          expect { subject.add_preprocessors(word_preprocessors: %i(bad word preprocessors)) }.to raise_error(/Argument word_preprocessor: does not respond to/)
+        end
+      end
+    end
+
+    context 'when passing a valid argument' do
+      before do
+        subject.replace_preprocessors word_preprocessors: word_preprocessors_04_thru_06
+      end
+
+      let(:expected_results) do
+        word_preprocessors_01_thru_03.concat(word_preprocessors_04_thru_06).sort_by(&:order)
+      end
+
+      it 'adds the word preprocessors to the #word_preprocessors and sorts the #word_preprocessors Array by WordPreprocessor#order' do
+        expect { subject.add_preprocessors word_preprocessors: word_preprocessors_01_thru_03 }.to \
+          change { subject.word_preprocessors.count }.from(3).to(6)
+        expect(subject.word_preprocessors).to eq expected_results
+      end
+    end
+
+    context 'when passing a nil argument' do
+      before do
+        subject.clear_preprocessors
+      end
+
+      context 'when a block is provided' do
+        it 'does NOT raise an error' do
+          expect do
+            subject.add_preprocessors { |_word_preprocessors| }
+          end.to_not raise_error
+        end
+
+        it 'uses the word preprocessors added via the block' do
+          expect do
+            subject.add_preprocessors do |word_preprocessors|
+              word_preprocessors.concat word_preprocessors_01_thru_03
+            end
+          end.to change { subject.word_preprocessors.count }.from(0).to(3)
+        end
+      end
+
+      context 'when a block is NOT provided' do
+        it 'raises an error' do
+          expect { subject.add_preprocessors }.to raise_error('A block is required if argument word_preprocessors is nil')
+        end
+      end
+    end
+  end
+
+  #replace_preprocessors
+  describe '#replace_preprocessors' do
+    before do
+      subject.add_preprocessors word_preprocessors: word_preprocessors_01_thru_03
+    end
+
+    let(:expected_results) do
+      word_preprocessors_04_thru_06.sort_by(&:order)
+    end
+
+    it 'replaces the word preprocessors in #word_preprocessors and sorts the #word_preprocessors Array by WordPreprocessor#order' do
+      expect(subject.word_preprocessors).to match_array word_preprocessors_01_thru_03
+      expect(subject.replace_preprocessors word_preprocessors: word_preprocessors_04_thru_06).to eq expected_results
+      expect(subject.word_preprocessors).to eq expected_results
+    end
+  end
+
+  #preprocessors_on=
+  describe '#preprocessors_on=' do
+    context 'when assigning true' do
+      before do
+        subject.preprocessors_on = false
+        expect(subject.word_preprocessors.map(&:preprocessor_on)).to all(be false)
+      end
+
+      it 'sets all preprocessors on' do
+        subject.preprocessors_on = true
+        expect(subject.word_preprocessors.map(&:preprocessor_on)).to all(be true)
+      end
+    end
+
+    context 'when assigning false' do
+      before do
+        subject.preprocessors_on = true
+        expect(subject.word_preprocessors.map(&:preprocessor_on)).to all(be true)
+      end
+
+      it 'sets all preprocessors off' do
+        subject.preprocessors_on = false
+        expect(subject.word_preprocessors.map(&:preprocessor_on)).to all(be false)
+      end
+    end
+  end
+
+  #preprocess
+  describe '#preprocess' do
+    before do
+      subject.add_preprocessors word_preprocessors: word_preprocessors
+    end
+
+    let(:word) { 'word' }
+    let(:word_preprocessors) { word_preprocessors_01_thru_03 }
+
+    it 'preprocesses the word' do
+      expect(subject.word_preprocessors.count).to eq word_preprocessors.count
+      expect(subject.preprocess(word: word).preprocessed_words.map(&:preprocessed_word)).to eq %w(word-0 word-0-1 word-0-1-2)
+    end
+  end
+end