polishgeeks-dev-tools 1.3.2 → 1.4.0

data/spec/lib/polish_geeks/dev_tools/commands/rubocop_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 RSpec.describe PolishGeeks::DevTools::Commands::Rubocop do
-  subject { described_class.new }
+  subject(:rubocop) { described_class.new }
   let(:config) { double }
   before { allow(PolishGeeks::DevTools::Config).to receive(:config) { config } }
 
@@ -21,105 +21,97 @@ RSpec.describe PolishGeeks::DevTools::Commands::Rubocop do
     context 'when app config exists' do
       let(:cmd) do
         "bundle exec rubocop #{PolishGeeks::DevTools.app_root}" \
-        " -c #{subject.class.config_manager.path}" \
+        " -c #{rubocop.class.config_manager.path}" \
         ' --require rubocop-rspec' \
         ' --display-cop-names'
       end
 
       before do
         expect(config).to receive(:rubocop_rspec?) { true }
-        allow(subject.class.config_manager).to receive(:application?) { true }
-        allow(subject.class.config_manager).to receive(:application_path) { path }
+        allow(rubocop.class.config_manager).to receive(:application?) { true }
+        allow(rubocop.class.config_manager).to receive(:application_path) { path }
         expect(instance).to receive(:execute).with(cmd)
       end
 
-      it { subject.execute }
+      it { rubocop.execute }
     end
 
     context 'when app config does not exist' do
       let(:path) { Dir.pwd }
       let(:cmd) do
         "bundle exec rubocop #{PolishGeeks::DevTools.app_root} " \
-        "-c #{subject.class.config_manager.path} " \
+        "-c #{rubocop.class.config_manager.path} " \
         '--display-cop-names'
       end
 
       before do
         allow(PolishGeeks::DevTools).to receive(:gem_root).and_return(path)
         expect(config).to receive(:rubocop_rspec?) { false }
-        allow(subject.class.config_manager).to receive(:application?) { false }
-        allow(subject.class.config_manager).to receive(:local_path) { path }
+        allow(rubocop.class.config_manager).to receive(:application?) { false }
+        allow(rubocop.class.config_manager).to receive(:local_path) { path }
         expect(instance).to receive(:execute).with(cmd)
       end
 
-      it { subject.execute }
+      it { rubocop.execute }
     end
   end
 
   describe '#valid?' do
     context 'when offenses count is equal 0' do
       before do
-        expect(subject)
+        expect(rubocop)
           .to receive(:offenses_count)
           .and_return(0)
       end
 
-      it 'returns true' do
-        expect(subject.valid?).to eq true
-      end
+      it { expect(rubocop.valid?).to eq true }
     end
 
     context 'when offenses count is different from 0' do
       before do
-        expect(subject)
+        expect(rubocop)
           .to receive(:offenses_count)
           .and_return(100)
       end
 
-      it 'returns false' do
-        expect(subject.valid?).to eq false
-      end
+      it { expect(rubocop.valid?).to eq false }
     end
   end
 
   describe '#label' do
     before do
-      expect(subject).to receive(:files_count) { 10 }
-      expect(subject).to receive(:offenses_count) { 5 }
+      expect(rubocop).to receive(:files_count) { 10 }
+      expect(rubocop).to receive(:offenses_count) { 5 }
     end
 
     context 'when we run rubocop' do
       before { expect(config).to receive(:rubocop_rspec?) { false } }
-      it { expect(subject.label).to eq 'Rubocop (10 files, 5 offenses)' }
+      it { expect(rubocop.label).to eq 'Rubocop (10 files, 5 offenses)' }
     end
 
     context 'when we run rubocop with rspec' do
       before { expect(config).to receive(:rubocop_rspec?) { true } }
-      it { expect(subject.label).to eq 'Rubocop with RSpec (10 files, 5 offenses)' }
+      it { expect(rubocop.label).to eq 'Rubocop with RSpec (10 files, 5 offenses)' }
     end
   end
 
   describe '#files_count' do
     context 'when we count files' do
       before do
-        subject.instance_variable_set(:@output, '10 files inspected')
+        rubocop.instance_variable_set(:@output, '10 files inspected')
       end
 
-      it 'returns a proper value' do
-        expect(subject.send(:files_count)).to eq 10
-      end
+      it { expect(rubocop.send(:files_count)).to eq 10 }
     end
   end
 
   describe '#offenses_count' do
     context 'when we count offenses' do
       before do
-        subject.instance_variable_set(:@output, '5 offenses detected')
+        rubocop.instance_variable_set(:@output, '5 offenses detected')
       end
 
-      it 'returns a proper value' do
-        expect(subject.send(:offenses_count)).to eq 5
-      end
+      it { expect(rubocop.send(:offenses_count)).to eq 5 }
     end
   end
 

data/spec/lib/polish_geeks/dev_tools/commands/rubycritic_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 RSpec.describe PolishGeeks::DevTools::Commands::Rubycritic do
-  subject { described_class.new }
+  subject(:rubycritic) { described_class.new }
 
   describe '#execute' do
     let(:instance) { instance_double(PolishGeeks::DevTools::Shell) }
@@ -13,9 +13,7 @@ RSpec.describe PolishGeeks::DevTools::Commands::Rubycritic do
           .with('bundle exec rubycritic ./app ./lib/')
       end
 
-      it 'executes the command' do
-        subject.execute
-      end
+      it { rubycritic.execute }
     end
   end
 

data/spec/lib/polish_geeks/dev_tools/commands/simplecov_spec.rb

@@ -2,29 +2,27 @@ require 'spec_helper'
 
 RSpec.describe PolishGeeks::DevTools::Commands::Simplecov do
   context 'class' do
-    subject { described_class }
+    subject(:simplecov) { described_class }
 
     describe '#validators' do
       it 'works only when we have Simplecov' do
-        expect(subject.validators).to eq [PolishGeeks::DevTools::Validators::Simplecov]
+        expect(simplecov.validators).to eq [PolishGeeks::DevTools::Validators::Simplecov]
       end
     end
   end
 
   context 'instance' do
-    subject { described_class.new }
+    subject(:simplecov) { described_class.new }
 
     let(:label) { '(95.00%) covered' }
     let(:config) { double }
 
     describe '#to_f' do
       context 'when we run simplecov' do
-        before do
-          subject.instance_variable_set(:@output, label)
-        end
+        before { simplecov.instance_variable_set(:@output, label) }
 
         it 'returns number of coverage as a float value' do
-          expect(subject.to_f).to eq 95.00
+          expect(simplecov.to_f).to eq 95.00
         end
       end
     end
@@ -33,20 +31,16 @@ RSpec.describe PolishGeeks::DevTools::Commands::Simplecov do
       context 'when we run simplecov' do
         let(:output) { OpenStruct.new(rspec: label) }
 
-        before do
-          subject.instance_variable_set(:@stored_output, output)
-        end
+        before { simplecov.instance_variable_set(:@stored_output, output) }
 
-        it 'executes the command' do
-          expect(subject.execute).to eq label
-        end
+        it { expect(simplecov.execute).to eq label }
       end
     end
 
     describe '#valid?' do
       context 'when cc level is greater or equal than expected' do
         before do
-          expect(subject)
+          expect(simplecov)
             .to receive(:to_f)
             .and_return(95.0)
           expect(PolishGeeks::DevTools::Config)
@@ -57,14 +51,12 @@ RSpec.describe PolishGeeks::DevTools::Commands::Simplecov do
             .and_return(65.0)
         end
 
-        it 'returns true' do
-          expect(subject.valid?).to eq true
-        end
+        it { expect(simplecov.valid?).to eq true }
       end
 
       context 'when cc level is less than expected' do
         before do
-          expect(subject)
+          expect(simplecov)
             .to receive(:to_f)
             .and_return(65.0)
           expect(PolishGeeks::DevTools::Config)
@@ -75,16 +67,14 @@ RSpec.describe PolishGeeks::DevTools::Commands::Simplecov do
             .and_return(95.0)
         end
 
-        it 'returns false' do
-          expect(subject.valid?).to eq false
-        end
+        it { expect(simplecov.valid?).to eq false }
       end
     end
 
     describe '#label' do
       context 'when we run simplecov and cc is greater or equal than expected' do
         before do
-          expect(subject)
+          expect(simplecov)
             .to receive(:to_f)
             .and_return(95.0)
           expect(PolishGeeks::DevTools::Config)
@@ -96,29 +86,29 @@ RSpec.describe PolishGeeks::DevTools::Commands::Simplecov do
         end
 
         it 'returns the label' do
-          expect(subject.label).to eq 'SimpleCov covered 95.0%, required 65.0%'
+          expect(simplecov.label).to eq 'SimpleCov covered 95.0%, required 65.0%'
         end
       end
     end
 
     describe '#error_message' do
       context 'when we run simplecov and cc is less than expected' do
-        before { allow(subject).to receive(:to_f) { 65.0 } }
+        before { allow(simplecov).to receive(:to_f) { 65.0 } }
 
         context 'and threshold is 95%' do
-          before { allow(subject).to receive(:threshold) { 95.0 } }
+          before { allow(simplecov).to receive(:threshold) { 95.0 } }
 
           it 'returns the error message' do
-            expect(subject.error_message)
+            expect(simplecov.error_message)
               .to eq 'SimpleCov coverage level needs to be 95.0% or more, was 65.0%'
           end
         end
 
         context 'and threshold is 100%' do
-          before { allow(subject).to receive(:threshold) { 100.0 } }
+          before { allow(simplecov).to receive(:threshold) { 100.0 } }
 
           it 'returns the error message' do
-            expect(subject.error_message)
+            expect(simplecov.error_message)
               .to eq 'SimpleCov coverage level needs to be 100.0%, was 65.0%'
           end
         end

data/spec/lib/polish_geeks/dev_tools/commands/tasks_files_names_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 RSpec.describe PolishGeeks::DevTools::Commands::TasksFilesNames do
-  subject { described_class.new }
+  subject(:tasks_files_names) { described_class.new }
 
   let(:config) { double }
 
@@ -23,19 +23,19 @@ RSpec.describe PolishGeeks::DevTools::Commands::TasksFilesNames do
 
   describe '#valid?' do
     before do
-      subject.instance_variable_set('@output', output)
+      tasks_files_names.instance_variable_set('@output', output)
     end
 
     context 'when output is empty' do
       let(:output) { [] }
 
-      it { expect(subject.valid?).to eq true }
+      it { expect(tasks_files_names.valid?).to eq true }
     end
 
     context 'when output is not empty' do
       let(:output) { ['file_name'] }
 
-      it { expect(subject.valid?).to eq false }
+      it { expect(tasks_files_names.valid?).to eq false }
     end
   end
 
@@ -44,10 +44,10 @@ RSpec.describe PolishGeeks::DevTools::Commands::TasksFilesNames do
     let(:expected) { "Tasks files names: #{counter} files checked" }
 
     before do
-      subject.instance_variable_set('@counter', counter)
+      tasks_files_names.instance_variable_set('@counter', counter)
     end
 
-    it { expect(subject.label).to eq expected }
+    it { expect(tasks_files_names.label).to eq expected }
   end
 
   describe '#error_message' do
@@ -55,54 +55,53 @@ RSpec.describe PolishGeeks::DevTools::Commands::TasksFilesNames do
     let(:expected) { "Following files have invalid extensions: \n #{output.join("\n")}\n" }
 
     before do
-      subject.instance_variable_set('@output', output)
+      tasks_files_names.instance_variable_set('@output', output)
     end
 
-    it { expect(subject.error_message).to eq expected }
+    it { expect(tasks_files_names.error_message).to eq expected }
   end
 
   describe '#files' do
     let(:dummy_type) do
       OpenStruct.new(
-        dirs: %w( lib )
+        dirs: %w(lib)
       )
     end
 
     it 'does not be empty' do
-      expect(subject.send(:files, dummy_type)).not_to be_empty
+      expect(tasks_files_names.send(:files, dummy_type)).not_to be_empty
     end
 
     it 'does not contain directories' do
-      expect(subject.send(:files, dummy_type)).not_to include('command')
+      expect(tasks_files_names.send(:files, dummy_type)).not_to include('command')
     end
   end
 
   describe '#execute' do
-    let(:example_cap_files) { %w( a b c test.cap ) }
-    let(:example_rake_files) { %w( d e f test.rake ) }
+    let(:example_cap_files) { %w(a b c test.cap) }
+    let(:example_rake_files) { %w(d e f test.rake) }
 
     before do
-      expect(subject)
+      expect(tasks_files_names)
         .to receive(:files)
         .with(described_class::CAP)
-        .and_return(example_cap_files)
+        .and_return(example_cap_files.dup)
 
-      expect(subject)
+      expect(tasks_files_names)
         .to receive(:files)
         .with(described_class::RAKE)
-        .and_return(example_rake_files)
+        .and_return(example_rake_files.dup)
+
+      tasks_files_names.execute
     end
 
     it 'sets counter' do
-      expected = example_cap_files.count + example_rake_files.count
-      subject.execute
-      expect(subject.counter).to eq expected
+      expect(
+        tasks_files_names.counter
+      ).to eq example_cap_files.count + example_rake_files.count
     end
 
-    it 'marks all inapropriate files' do
-      subject.execute
-      expect(subject.output).not_to include('test.cap')
-      expect(subject.output).not_to include('test.rake')
-    end
+    it { expect(tasks_files_names.output).not_to include('test.cap') }
+    it { expect(tasks_files_names.output).not_to include('test.rake') }
   end
 end

data/spec/lib/polish_geeks/dev_tools/commands/yard_spec.rb

@@ -1,54 +1,40 @@
 require 'spec_helper'
 
 RSpec.describe PolishGeeks::DevTools::Commands::Yard do
-  subject { described_class.new }
+  subject(:yard) { described_class.new }
 
   describe '#execute' do
     let(:instance) { instance_double(PolishGeeks::DevTools::Shell) }
 
     context 'when we run yard' do
       before do
-        expect(subject).to receive(:options) { '--list-undoc' }
+        expect(yard).to receive(:options) { '--list-undoc' }
         allow(PolishGeeks::DevTools::Shell).to receive(:new) { instance }
         expect(instance).to receive(:execute)
           .with('bundle exec yard stats --list-undoc')
       end
 
-      it 'executes the command' do
-        subject.execute
-      end
+      it { yard.execute }
     end
   end
 
   describe '#valid?' do
     context 'when everything is documented and without warnings' do
-      before do
-        subject.instance_variable_set(:@output, 'OK')
-      end
+      before { yard.instance_variable_set(:@output, 'OK') }
 
-      it 'returns true' do
-        expect(subject.valid?).to eq true
-      end
+      it { expect(yard.valid?).to eq true }
     end
 
     context 'when something has some warnings' do
-      before do
-        subject.instance_variable_set(:@output, 'warn')
-      end
+      before { yard.instance_variable_set(:@output, 'warn') }
 
-      it 'returns false' do
-        expect(subject.valid?).to eq false
-      end
+      it { expect(yard.valid?).to eq false }
     end
 
     context 'when something is undocumented' do
-      before do
-        subject.instance_variable_set(:@output, 'undocumented objects')
-      end
+      before { yard.instance_variable_set(:@output, 'undocumented objects') }
 
-      it 'returns false' do
-        expect(subject.valid?).to eq false
-      end
+      it { expect(yard.valid?).to eq false }
     end
   end
 
@@ -71,7 +57,7 @@ RSpec.describe PolishGeeks::DevTools::Commands::Yard do
       end
 
       it 'returns lines with options' do
-        expect(subject.send(:options)).to eq '--private --list-undoc'
+        expect(yard.send(:options)).to eq '--private --list-undoc'
       end
     end
   end