LittleWeasel 3.0.3 → 5.0.0

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

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

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Preprocessors::WordPreprocessor do
+  subject do
+    word_preprocessor = described_class.new order: order
+    word_preprocessor.preprocessor_on = preprocessor_on
+    word_preprocessor
+  end
+
+  let(:preprocessor_on) { true }
+  let(:order) { 0 }
+  let(:word) { 'word' }
+
+  #.new
+  describe '.new' do
+    context 'when arguments are valid' do
+      it 'instantiates the object' do
+        expect { subject }.to_not raise_error
+      end
+    end
+
+    context 'when arguments are INVALID' do
+      context 'when argument order is invalid' do
+        context 'when order is not an Integer' do
+          let(:order) { :not_an_integer }
+
+          it 'raises an error' do
+            expect { subject }.to raise_error(/Argument order is not an Integer/)
+          end
+        end
+
+        context 'when order is negative' do
+          let(:order) { -1 }
+
+          it 'raises an error' do
+            expect { subject }.to raise_error "Argument order '#{order}' is not a a number from 0-n"
+          end
+        end
+      end
+
+      context 'when argument preprocessor_on is invalid' do
+        context 'when preprocessor_on is not true or false' do
+          let(:preprocessor_on) { :not_true_or_false }
+
+          it 'raises an error' do
+            expect { subject }.to raise_error "Argument value is not true or false: #{preprocessor_on}"
+          end
+        end
+      end
+    end
+  end
+
+  #.preprocess
+  describe '.preprocess' do
+    context 'when not overridden' do
+      it 'raises an error' do
+        expect { subject.class.preprocess word }.to raise_error LittleWeasel::Errors::MustOverrideError
+      end
+    end
+  end
+
+  #preprocessor_on
+  describe '#preprocessor_on' do
+    context 'when set to true' do
+      before do
+        subject.preprocessor_on = true
+      end
+
+      it 'returns true' do
+        expect(subject.preprocessor_on).to eq true
+      end
+    end
+
+    context 'when set to false' do
+      before do
+        subject.preprocessor_on = false
+      end
+
+      it 'returns false' do
+        expect(subject.preprocessor_on).to eq false
+      end
+    end
+  end
+
+  #preprocessor_on!
+  describe '#preprocessor_on!' do
+    before do
+      expect(subject.preprocessor_off?).to eq true
+    end
+
+    let(:preprocessor_on) { false }
+
+    it 'turns the preprocessor on' do
+      subject.preprocessor_on!
+      expect(subject.preprocessor_on).to eq true
+    end
+  end
+
+  #preprocessor_on?
+  describe '#preprocessor_on?' do
+    context 'when #preprocessor_on is true' do
+      it 'returns true' do
+        expect(subject.preprocessor_on?).to eq true
+      end
+    end
+
+    context 'when #preprocessor_on is false' do
+      let(:preprocessor_on) { false }
+
+      it 'returns false' do
+        expect(subject.preprocessor_on?).to eq false
+      end
+    end
+  end
+
+  #preprocess
+  describe '#preprocess' do
+    context 'when not overridden' do
+      it 'raises an error' do
+        expect { subject.preprocess 'x' }.to raise_error LittleWeasel::Errors::MustOverrideError
+      end
+    end
+
+    context 'when overridden' do
+      before do
+        allow(described_class).to receive(:preprocess?)
+          .and_return true
+        allow(described_class).to receive(:preprocess)
+          .and_return [true, 'preprocessed-word']
+      end
+
+      context 'when #preprocessor_on? is true' do
+        it 'calls .preprocess and returns a ProcessedWord object' do
+          expect(described_class).to receive(:preprocess)
+          expect(subject.preprocess word).to be_kind_of LittleWeasel::Preprocessors::PreprocessedWord
+        end
+      end
+
+      context 'when #preprocessor_on? is false' do
+        let(:preprocessor_on) { false }
+
+        it 'does NOT call .preprocess and returns a ProcessedWord object' do
+          expect(described_class).to_not receive(:preprocess)
+          expect(subject.preprocess word).to be_kind_of LittleWeasel::Preprocessors::PreprocessedWord
+        end
+
+      end
+    end
+  end
+
+  #preprocess?
+  describe '#preprocess?' do
+    let(:word) { 'word' }
+
+    it 'returns true by default' do
+      expect(subject.preprocess? word).to be true
+    end
+
+    context 'when #preprocess? returns true' do
+      before { allow(subject.class).to receive(:preprocess?).and_return(true) }
+
+      context 'when #preprocessor_on? is true' do
+        it_behaves_like 'the preprocessor matches and #preprocessor_on? is true'
+      end
+
+      context 'when #preprocessor_on? is false' do
+        let(:preprocessor_on) { false }
+
+        it_behaves_like 'the preprocessor matches and #preprocessor_on? is false'
+      end
+    end
+
+    context 'when #preprocess? returns false' do
+      before { allow(subject.class).to receive(:preprocess?).and_return(false) }
+
+      context 'when #preprocessor_on? is true' do
+        it_behaves_like 'the preprocessor DOES NOT match and #preprocessor_on? is true'
+      end
+
+      context 'when #preprocessor_on? is false' do
+        let(:preprocessor_on) { false }
+
+        it_behaves_like 'the preprocessor DOES NOT match and #preprocessor_on? is false'
+      end
+    end
+  end
+
+  #preprocessor_off?
+  describe '#preprocessor_off?' do
+    context 'when #preprocessor_on is false' do
+      let(:preprocessor_on) { false }
+
+      it 'returns true' do
+        expect(subject.preprocessor_off?).to eq true
+      end
+    end
+
+    context 'when #preprocessor_on is true' do
+      it 'returns false' do
+        expect(subject.preprocessor_off?).to eq false
+      end
+    end
+  end
+
+  #preprocessor_off!
+  describe '#preprocessor_off!' do
+    before do
+      expect(subject.preprocessor_on?).to eq true
+    end
+
+    it 'turns the preprocessor off' do
+      subject.preprocessor_off!
+      expect(subject.preprocessor_on).to eq false
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Preprocessors::WordPreprocessorValidatable, type: :module do
+  subject { MockSubject.new }
+
+  WordPreprocessorValidatable = described_class
+
+  class MockSubject
+    include WordPreprocessorValidatable
+  end
+
+  class MockWordPreprocessor < LittleWeasel::Preprocessors::WordPreprocessor
+    def preprocess(word)
+      [true, "#{word}-preprocessed"]
+    end
+  end
+
+  let(:order) { 0 }
+  let(:preprocessor_on) { true }
+  let(:word_preprocessor) do
+    word_preprocessor = MockWordPreprocessor.new order: order
+    word_preprocessor.preprocessor_on = preprocessor_on
+    word_preprocessor
+  end
+
+  shared_examples 'an instance method is missing' do
+    before do
+      allow(word_preprocessor).to receive(:respond_to?).with(method).and_return(false)
+    end
+
+    it 'raises an error' do
+      expect { WordPreprocessorValidatable.validate_word_preprocessor word_preprocessor: word_preprocessor }.to raise_error expected_error_message
+    end
+  end
+
+  shared_examples 'a class method is missing' do
+    before do
+      allow(word_preprocessor.class).to receive(:respond_to?).with(method).and_return(false)
+    end
+
+    it 'raises an error' do
+      expect { WordPreprocessorValidatable.validate_word_preprocessor word_preprocessor: word_preprocessor }.to raise_error expected_error_message
+    end
+  end
+
+  #.validate_word_preprocessor
+  describe '.validate_word_preprocessor' do
+    before do
+      allow(word_preprocessor.class).to receive(:respond_to?).and_call_original
+      allow(word_preprocessor).to receive(:respond_to?).and_call_original
+    end
+
+    context 'when the object quacks right' do
+      it 'passes validation' do
+        expect { WordPreprocessorValidatable.validate_word_preprocessor word_preprocessor: word_preprocessor }.to_not raise_error
+      end
+    end
+
+    context 'when the object DOES NOT quack right' do
+      let(:expected_error_message) { /Argument word_preprocessor: does not respond to/ }
+
+      context 'when a class method is missing' do
+        context 'when the class does not respond to .preprocess' do
+          let(:method) { :preprocess }
+          it_behaves_like 'a class method is missing'
+        end
+
+        context 'when the class does not respond to .preprocess?' do
+          let(:method) { :preprocess? }
+          it_behaves_like 'a class method is missing'
+        end
+      end
+
+      context 'when an instance method is missing' do
+        context 'when the object does not respond to #preprocess' do
+          let(:method) { :preprocess }
+          it_behaves_like 'an instance method is missing'
+        end
+
+        context 'when the object does not respond to #preprocess?' do
+          let(:method) { :preprocess? }
+          it_behaves_like 'an instance method is missing'
+        end
+
+        context 'when the object does not respond to #preprocessor_off?' do
+          let(:method) { :preprocessor_off? }
+          it_behaves_like 'an instance method is missing'
+        end
+
+        context 'when the object does not respond to #preprocessor_on' do
+          let(:method) { :preprocessor_on }
+          it_behaves_like 'an instance method is missing'
+        end
+
+        context 'when the object does not respond to #preprocessor_on=' do
+          let(:method) { :preprocessor_on= }
+          it_behaves_like 'an instance method is missing'
+        end
+
+        context 'when the object does not respond to #preprocessor_on?' do
+          let(:method) { :preprocessor_on? }
+          it_behaves_like 'an instance method is missing'
+        end
+      end
+    end
+  end
+end