discourse_image_optim 0.24.4

data/spec/image_optim/handler_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'image_optim/handler'
+
+describe ImageOptim::Handler do
+  before do
+    stub_const('Handler', ImageOptim::Handler)
+  end
+
+  it 'uses original as source for first conversion '\
+      'and two temp files for further conversions' do
+    original = double(:original)
+    allow(original).to receive(:respond_to?).with(:temp_path).and_return(true)
+
+    handler = Handler.new(original)
+    temp_a = double(:temp_a)
+    temp_b = double(:temp_b)
+    expect(original).to receive(:temp_path).and_return(temp_a, temp_b)
+
+    # first unsuccessful run
+    handler.process do |src, dst|
+      expect([src, dst]).to eq([original, temp_a]); false
+    end
+    expect(handler.result).to be_nil
+
+    # first successful run
+    handler.process do |src, dst|
+      expect([src, dst]).to eq([original, temp_a]); true
+    end
+    expect(handler.result).to eq(temp_a)
+
+    # second unsuccessful run
+    handler.process do |src, dst|
+      expect([src, dst]).to eq([temp_a, temp_b]); false
+    end
+    expect(handler.result).to eq(temp_a)
+
+    # second successful run
+    handler.process do |src, dst|
+      expect([src, dst]).to eq([temp_a, temp_b]); true
+    end
+    expect(handler.result).to eq(temp_b)
+
+    # third successful run
+    handler.process do |src, dst|
+      expect([src, dst]).to eq([temp_b, temp_a]); true
+    end
+    expect(handler.result).to eq(temp_a)
+
+    # forth successful run
+    handler.process do |src, dst|
+      expect([src, dst]).to eq([temp_a, temp_b]); true
+    end
+    expect(handler.result).to eq(temp_b)
+
+    expect(temp_a).to receive(:unlink).once
+    handler.cleanup
+    handler.cleanup
+  end
+
+  describe '.for' do
+    it 'yields instance, runs cleanup and returns result' do
+      original = double
+      handler = double
+      result = double
+
+      expect(Handler).to receive(:new).
+        with(original).and_return(handler)
+      expect(handler).to receive(:process)
+      expect(handler).to receive(:cleanup)
+      expect(handler).to receive(:result).and_return(result)
+
+      expect(Handler.for(original, &:process)).to eq(result)
+    end
+
+    it 'cleans up if exception is raised' do
+      original = double
+      handler = double
+
+      expect(Handler).to receive(:new).
+        with(original).and_return(handler)
+      expect(handler).to receive(:cleanup)
+
+      expect do
+        Handler.for(original) do
+          fail 'hello'
+        end
+      end.to raise_error 'hello'
+    end
+  end
+end

data/spec/image_optim/hash_helpers_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'image_optim/hash_helpers'
+
+describe ImageOptim::HashHelpers do
+  before do
+    stub_const('HashHelpers', ImageOptim::HashHelpers)
+  end
+
+  context 'stringify/simbolyze' do
+    symbol_keys = {
+      :a => 1,
+      :b => {
+        :c => [:a, 'a'],
+        :d => {},
+      },
+    }
+
+    string_keys = {
+      'a' => 1,
+      'b' => {
+        'c' => [:a, 'a'],
+        'd' => {},
+      },
+    }
+
+    it 'deep stringifies hash keys' do
+      expect(HashHelpers.deep_stringify_keys(symbol_keys)).to eq(string_keys)
+      expect(HashHelpers.deep_stringify_keys(string_keys)).to eq(string_keys)
+    end
+
+    it 'deep symbolises hash keys' do
+      expect(HashHelpers.deep_symbolise_keys(string_keys)).to eq(symbol_keys)
+      expect(HashHelpers.deep_symbolise_keys(symbol_keys)).to eq(symbol_keys)
+    end
+  end
+
+  it 'deep merges hashes' do
+    merge_a = {
+      :a => {
+        :b => 1,
+        :c => {
+          :d => 2,
+          :e => {:f => true},
+        },
+      },
+      :y => 10,
+    }
+
+    merge_b = {
+      :a => {
+        :b => 2,
+        :c => {
+          :d => 3,
+          :e => false,
+        },
+      },
+      'z' => 20,
+    }
+
+    merge_result = {
+      :a => {
+        :b => 2,
+        :c => {
+          :d => 3,
+          :e => false,
+        },
+      },
+      :y => 10,
+      'z' => 20,
+    }
+
+    expect(HashHelpers.deep_merge(merge_a, merge_b)).to eq(merge_result)
+  end
+end

data/spec/image_optim/image_meta_spec.rb

@@ -0,0 +1,61 @@
+require 'image_optim/image_meta'
+
+describe ImageOptim::ImageMeta do
+  let(:image_path){ 'spec/images/lena.jpg' }
+  let(:non_image_path){ __FILE__ }
+  let(:broken_image_path){ 'spec/images/broken_jpeg' }
+
+  describe '.format_for_path' do
+    context 'for an image' do
+      it 'returns format' do
+        expect(described_class.format_for_path(image_path)).
+          to eq(:jpeg)
+      end
+    end
+
+    context 'for broken image' do
+      it 'warns and returns nil' do
+        expect(described_class).to receive(:warn)
+
+        expect(described_class.format_for_path(broken_image_path)).
+          to eq(nil)
+      end
+    end
+
+    context 'for not an image' do
+      it 'does not warn and returns nil' do
+        expect(described_class).not_to receive(:warn)
+
+        expect(described_class.format_for_path(non_image_path)).
+          to eq(nil)
+      end
+    end
+  end
+
+  describe '.format_for_data' do
+    context 'for image data' do
+      it 'returns format' do
+        expect(described_class.format_for_data(File.read(image_path))).
+          to eq(:jpeg)
+      end
+    end
+
+    context 'for broken image data' do
+      it 'warns and returns nil' do
+        expect(described_class).to receive(:warn)
+
+        expect(described_class.format_for_data(File.read(broken_image_path))).
+          to eq(nil)
+      end
+    end
+
+    context 'for not an image data' do
+      it 'does not warn and returns nil' do
+        expect(described_class).not_to receive(:warn)
+
+        expect(described_class.format_for_data(File.read(non_image_path))).
+          to eq(nil)
+      end
+    end
+  end
+end

data/spec/image_optim/optimized_path_spec.rb

@@ -0,0 +1,58 @@
+require 'image_optim/optimized_path'
+
+describe ImageOptim::OptimizedPath do
+  describe '#initialize' do
+    context 'when second argument is original' do
+      subject{ described_class.new('a', 'b') }
+
+      before do
+        allow_any_instance_of(ImageOptim::Path).
+          to receive(:size).and_return(616)
+      end
+
+      it 'delegates to optimized path as Path' do
+        is_expected.to eq(ImageOptim::Path.new('a'))
+      end
+
+      it 'returns original path as Path for original' do
+        expect(subject.original).to eq(ImageOptim::Path.new('b'))
+      end
+
+      it 'returns original size for original_size' do
+        expect(subject.original_size).to eq(616)
+      end
+    end
+
+    context 'when second argument is size' do
+      subject{ described_class.new('a', 616) }
+
+      it 'delegates to optimized path as Path' do
+        is_expected.to eq(ImageOptim::Path.new('a'))
+      end
+
+      it 'returns optimized path as Path for original' do
+        expect(subject.original).to eq(ImageOptim::Path.new('a'))
+      end
+
+      it 'returns size for original_size' do
+        expect(subject.original_size).to eq(616)
+      end
+    end
+
+    context 'when no second argument' do
+      subject{ described_class.new('a') }
+
+      it 'delegates to optimized path as Path' do
+        is_expected.to eq(ImageOptim::Path.new('a'))
+      end
+
+      it 'returns nil for original' do
+        expect(subject.original).to eq(nil)
+      end
+
+      it 'returns nil for original_size' do
+        expect(subject.original_size).to eq(nil)
+      end
+    end
+  end
+end

data/spec/image_optim/option_definition_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+require 'image_optim/option_definition'
+
+describe ImageOptim::OptionDefinition do
+  describe 'initialization' do
+    context 'when type is not specified explicitly' do
+      subject{ described_class.new('abc', :def, 'desc') }
+
+      describe '#name' do
+        it{ expect(subject.name).to eq(:abc) }
+      end
+
+      describe '#default' do
+        it{ expect(subject.default).to eq(:def) }
+      end
+
+      describe '#type' do
+        it{ expect(subject.type).to eq(Symbol) }
+      end
+
+      describe '#description' do
+        it{ expect(subject.description).to eq('desc') }
+      end
+    end
+
+    context 'when type is specified explicitly' do
+      subject{ described_class.new('abc', :def, Hash, 'desc') }
+
+      describe '#name' do
+        it{ expect(subject.name).to eq(:abc) }
+      end
+
+      describe '#default' do
+        it{ expect(subject.default).to eq(:def) }
+      end
+
+      describe '#type' do
+        it{ expect(subject.type).to eq(Hash) }
+      end
+
+      describe '#description' do
+        it{ expect(subject.description).to eq('desc') }
+      end
+    end
+  end
+
+  describe '#value' do
+    context 'when proc not given' do
+      subject{ described_class.new('abc', :def, 'desc') }
+
+      context 'when option not provided' do
+        it 'returns default' do
+          expect(subject.value(nil, {})).to eq(:def)
+        end
+      end
+
+      context 'when option is nil' do
+        it 'returns nil' do
+          expect(subject.value(nil, :abc => nil)).to eq(nil)
+        end
+      end
+
+      context 'when option is set' do
+        it 'returns value' do
+          expect(subject.value(nil, :abc => 123)).to eq(123)
+        end
+      end
+    end
+
+    context 'when proc given' do
+      subject do
+        # not using &:inspect due to ruby Bug #13087
+        # to_s is just to calm rubocop
+        described_class.new('abc', :def, 'desc'){ |o| o.inspect.to_s }
+      end
+
+      context 'when option not provided' do
+        it 'returns default passed through proc' do
+          expect(subject.value(nil, {})).to eq(':def')
+        end
+      end
+
+      context 'when option is nil' do
+        it 'returns nil passed through proc' do
+          expect(subject.value(nil, :abc => nil)).to eq('nil')
+        end
+      end
+
+      context 'when option is set' do
+        it 'returns value passed through proc' do
+          expect(subject.value(nil, :abc => 123)).to eq('123')
+        end
+      end
+    end
+
+    context 'when proc with arity 2 given' do
+      subject do
+        described_class.new('abc', :def, 'desc'){ |a, b| [a.inspect, b] }
+      end
+
+      context 'when option not provided' do
+        it 'returns default passed through proc' do
+          expect(subject.value(nil, {})).to eq([':def', subject])
+        end
+      end
+
+      context 'when option is nil' do
+        it 'returns nil passed through proc' do
+          expect(subject.value(nil, :abc => nil)).to eq(['nil', subject])
+        end
+      end
+
+      context 'when option is set' do
+        it 'returns value passed through proc' do
+          expect(subject.value(nil, :abc => 123)).to eq(['123', subject])
+        end
+      end
+    end
+  end
+
+  describe '#default_description' do
+    context 'when default is not a string' do
+      subject{ described_class.new('abc', :def, 'desc') }
+
+      it 'returns inspected value in backticks' do
+        expect(subject.default_description).to eq('`:def`')
+      end
+    end
+
+    context 'when default is a string' do
+      subject{ described_class.new('abc', '`1`', 'desc') }
+
+      it 'returns it as is' do
+        expect(subject.default_description).to eq('`1`')
+      end
+    end
+  end
+end

data/spec/image_optim/option_helpers_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'image_optim/option_helpers'
+
+describe ImageOptim::OptionHelpers do
+  describe '.limit_with_range' do
+    {
+      2..4 => 'inclusive',
+      2...5 => 'exclusive',
+    }.each do |range, type|
+      context "for an end #{type} range" do
+        it 'returns number when it is in range' do
+          expect(described_class.limit_with_range(4, range)).to eq(4)
+        end
+
+        it 'returns begin when it is less than minimum' do
+          expect(described_class.limit_with_range(1, range)).to eq(2)
+        end
+
+        it 'returns end when it is more than maximum' do
+          expect(described_class.limit_with_range(10, range)).to eq(4)
+        end
+      end
+    end
+  end
+end