polishgeeks-dev-tools 1.3.2 → 1.4.0

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 RSpec.describe PolishGeeks::DevTools::Commands::YmlParser do
-  subject { described_class.new }
+  subject(:yml_parser) { described_class.new }
 
   let(:config) { double }
   let(:file) { rand.to_s }
@@ -15,48 +15,44 @@ RSpec.describe PolishGeeks::DevTools::Commands::YmlParser do
       expect(Dir)
         .to receive(:[])
         .and_return(results)
-      expect(subject)
+      expect(yml_parser)
         .to receive(:parse_yaml)
         .with(file)
         .and_return(json)
-      expect(subject)
+      expect(yml_parser)
         .to receive(:check_params)
         .and_return(json)
     end
 
-    it 'executes the command' do
-      subject.execute
-    end
+    it { yml_parser.execute }
   end
 
   describe '#label' do
-    it { expect(subject.label).to eq 'Yaml parser' }
+    it { expect(yml_parser.label).to eq 'Yaml parser' }
   end
 
   describe '#error_message' do
     let(:output) { [file: file, lines: [line]] }
     let(:expected) { "Following yml files have nil as a value:\n#{file}:\n - Key '#{line}'\n" }
     before do
-      subject.instance_variable_set('@output', output)
+      yml_parser.instance_variable_set('@output', output)
     end
 
     it 'returns lines with nil value' do
-      expect(subject.error_message).to eq expected
+      expect(yml_parser.error_message).to eq expected
     end
   end
 
   describe '#valid?' do
-    before do
-      subject.instance_variable_set('@output', '')
-    end
+    before { yml_parser.instance_variable_set('@output', '') }
 
-    it { expect(subject.valid?).to eq true }
+    it { expect(yml_parser.valid?).to eq true }
   end
 
   describe '#file_error' do
     let(:expected) { "\n#{file}:\n - Key '#{line}'" }
 
-    it { expect(subject.send(:file_error, row)).to eq expected }
+    it { expect(yml_parser.send(:file_error, row)).to eq expected }
   end
 
   describe '#config_path' do
@@ -66,13 +62,13 @@ RSpec.describe PolishGeeks::DevTools::Commands::YmlParser do
         .to receive(:expand_path)
         .and_return('')
     end
-    it { expect(subject.send(:config_path)).to eq expected }
+    it { expect(yml_parser.send(:config_path)).to eq expected }
   end
 
   describe '#sanitize' do
     let(:file_path) { PolishGeeks::DevTools.app_root + '/config/' + file }
 
-    it { expect(subject.send(:sanitize, file_path)).to eq file }
+    it { expect(yml_parser.send(:sanitize, file_path)).to eq file }
   end
 
   describe '#parse_yaml' do
@@ -85,20 +81,20 @@ RSpec.describe PolishGeeks::DevTools::Commands::YmlParser do
         .to receive(:load)
         .and_return(file)
     end
-    it { expect(subject.send(:parse_yaml, file)).to eq file }
+    it { expect(yml_parser.send(:parse_yaml, file)).to eq file }
   end
 
   describe '#check_params' do
     context 'when file have nil value' do
       let(:hash) { { key: 'my_key', val: { user: 'test', pass: nil } } }
 
-      it { expect(subject.send(:check_params, hash)).to eq [:pass] }
+      it { expect(yml_parser.send(:check_params, hash)).to eq [:pass] }
     end
 
     context 'when file have not nil value' do
       let(:hash) { { key: 'key', val: 'val' } }
 
-      it { expect(subject.send(:check_params, hash)).to be_empty }
+      it { expect(yml_parser.send(:check_params, hash)).to be_empty }
     end
   end
 end

data/spec/lib/polish_geeks/dev_tools/config_manager_spec.rb

@@ -1,26 +1,26 @@
 require 'spec_helper'
 
 RSpec.describe PolishGeeks::DevTools::ConfigManager do
+  subject(:config_manager) { described_class.new(name) }
   let(:name) { 'rubocop.yml' }
   let(:path) { '/path/to/config' }
-  subject { described_class.new(name) }
 
   describe '#present?' do
     context 'when application config exist' do
-      before { allow(subject).to receive(:application?) { true } }
-      it { expect(subject.present?).to be true }
+      before { allow(config_manager).to receive(:application?) { true } }
+      it { expect(config_manager.present?).to be true }
     end
 
     context 'when application config does not exist' do
-      before { allow(subject).to receive(:application?) { false } }
+      before { allow(config_manager).to receive(:application?) { false } }
       context 'and local config exist' do
-        before { allow(subject).to receive(:local?) { true } }
-        it { expect(subject.present?).to be true }
+        before { allow(config_manager).to receive(:local?) { true } }
+        it { expect(config_manager.present?).to be true }
       end
 
       context 'and local config does not exist' do
-        before { allow(subject).to receive(:local?) { false } }
-        it { expect(subject.present?).to be false }
+        before { allow(config_manager).to receive(:local?) { false } }
+        it { expect(config_manager.present?).to be false }
       end
     end
   end
@@ -28,20 +28,20 @@ RSpec.describe PolishGeeks::DevTools::ConfigManager do
   describe '#path' do
     context 'when application config exist' do
       before do
-        allow(subject).to receive(:application?) { true }
-        expect(subject).to receive(:application_path) { path }
+        allow(config_manager).to receive(:application?) { true }
+        expect(config_manager).to receive(:application_path) { path }
       end
-      it { expect(subject.path).to eq path }
+      it { expect(config_manager.path).to eq path }
     end
 
     context 'when application config does not exist' do
       let(:path2) { '/path/to/config2' }
       before do
-        allow(subject).to receive(:application?) { false }
-        expect(subject).to receive(:application_path).never
-        expect(subject).to receive(:local_path) { path2 }
+        allow(config_manager).to receive(:application?) { false }
+        expect(config_manager).to receive(:application_path).never
+        expect(config_manager).to receive(:local_path) { path2 }
       end
-      it { expect(subject.path).to be path2 }
+      it { expect(config_manager.path).to be path2 }
     end
   end
 
@@ -52,29 +52,29 @@ RSpec.describe PolishGeeks::DevTools::ConfigManager do
       end
 
       context 'and file exist' do
-        before { expect(subject).to receive(:local_path) { path } }
-        it { expect(subject.send(:local?)).to be true }
+        before { expect(config_manager).to receive(:local_path) { path } }
+        it { expect(config_manager.send(:local?)).to be true }
       end
 
       context 'and file does not exist' do
-        before { expect(subject).to receive(:local_path) { nil } }
-        it { expect(subject.send(:local?)).to be false }
+        before { expect(config_manager).to receive(:local_path) { nil } }
+        it { expect(config_manager.send(:local?)).to be false }
       end
     end
 
     context 'when config name not present' do
-      subject { described_class.new(nil) }
-      it { expect(subject.send(:local?)).to be false }
+      subject(:config_manager) { described_class.new(nil) }
+      it { expect(config_manager.send(:local?)).to be false }
     end
   end
 
   describe '#local_path' do
     before do
       allow(PolishGeeks::DevTools).to receive(:gem_root) { path }
-      expect(subject).to receive(:fetch_path).with(path) { path }
+      expect(config_manager).to receive(:fetch_path).with(path) { path }
     end
 
-    it { expect(subject.send(:local_path)).to eq(path) }
+    it { expect(config_manager.send(:local_path)).to eq(path) }
   end
 
   describe '#application?' do
@@ -84,29 +84,29 @@ RSpec.describe PolishGeeks::DevTools::ConfigManager do
       end
 
       context 'and file exist' do
-        before { expect(subject).to receive(:application_path) { path } }
-        it { expect(subject.send(:application?)).to be true }
+        before { expect(config_manager).to receive(:application_path) { path } }
+        it { expect(config_manager.send(:application?)).to be true }
       end
 
       context 'and file does not exist' do
-        before { expect(subject).to receive(:application_path) { nil } }
-        it { expect(subject.send(:application?)).to be false }
+        before { expect(config_manager).to receive(:application_path) { nil } }
+        it { expect(config_manager.send(:application?)).to be false }
       end
     end
 
     context 'when config name not present' do
-      subject { described_class.new(nil) }
-      it { expect(subject.send(:application?)).to be false }
+      subject(:config_manager) { described_class.new(nil) }
+      it { expect(config_manager.send(:application?)).to be false }
     end
   end
 
   describe '#application_path' do
     before do
       allow(PolishGeeks::DevTools).to receive(:app_root) { path }
-      expect(subject).to receive(:fetch_path).with(path) { path }
+      expect(config_manager).to receive(:fetch_path).with(path) { path }
     end
 
-    it { expect(subject.send(:application_path)).to eq(path) }
+    it { expect(config_manager.send(:application_path)).to eq(path) }
   end
 
   describe '#fetch_path' do
@@ -114,11 +114,11 @@ RSpec.describe PolishGeeks::DevTools::ConfigManager do
 
     context 'file exist' do
       before { expect(File).to receive(:exist?).with(config_file) { true } }
-      it { expect(subject.send(:fetch_path, path)).to eq(config_file) }
+      it { expect(config_manager.send(:fetch_path, path)).to eq(config_file) }
     end
 
     context 'file does not exist' do
-      it { expect(subject.send(:fetch_path, path)).to be nil }
+      it { expect(config_manager.send(:fetch_path, path)).to be nil }
     end
   end
 end

data/spec/lib/polish_geeks/dev_tools/config_spec.rb

@@ -1,37 +1,37 @@
 require 'spec_helper'
 
 RSpec.describe PolishGeeks::DevTools::Config do
-  subject { described_class.new }
+  subject(:config) { described_class.new }
 
   described_class::COMMANDS.each do |attribute|
     describe "#{attribute}=" do
       let(:value) { rand }
-      before { subject.public_send(:"#{attribute}=", value) }
+      before { config.public_send(:"#{attribute}=", value) }
 
       it 'assigns a given value' do
-        expect(subject.public_send(attribute)).to eq value
+        expect(config.public_send(attribute)).to eq value
       end
     end
 
     describe "#{attribute}?" do
       let(:value) { rand(2) == 0 }
-      before { subject.public_send(:"#{attribute}=", value) }
+      before { config.public_send(:"#{attribute}=", value) }
 
       it 'assigns a given value' do
-        expect(subject.public_send(:"#{attribute}?")).to eq value
+        expect(config.public_send(:"#{attribute}?")).to eq value
       end
     end
   end
 
   describe '.setup' do
-    subject { described_class }
+    subject(:config) { described_class }
     let(:instance) { described_class.new }
     let(:block) { -> {} }
 
     before do
       instance
 
-      expect(subject)
+      expect(config)
         .to receive(:new)
         .and_return(instance)
 
@@ -43,18 +43,18 @@ RSpec.describe PolishGeeks::DevTools::Config do
         .to receive(:freeze)
     end
 
-    it { subject.setup(&block) }
+    it { config.setup(&block) }
   end
 
   describe '#initialize' do
     described_class::COMMANDS.each do |attribute|
       it "should have #{attribute} command turned on by default" do
-        expect(subject.public_send(attribute)).to eq true
+        expect(config.public_send(attribute)).to eq true
       end
     end
 
     it 'has simplecov_threshold set to 100 by default' do
-      expect(subject.simplecov_threshold).to eq 100
+      expect(config.simplecov_threshold).to eq 100
     end
   end
 end

data/spec/lib/polish_geeks/dev_tools/errors_spec.rb

@@ -2,14 +2,14 @@ require 'spec_helper'
 
 RSpec.describe PolishGeeks::DevTools::Errors do
   describe 'BaseError' do
-    subject { described_class::BaseError }
+    subject(:errors) { described_class::BaseError }
 
-    specify { expect(subject).to be < StandardError }
+    specify { expect(errors).to be < StandardError }
   end
 
   describe 'NotImplementedError' do
-    subject { described_class::NotImplementedError }
+    subject(:errors) { described_class::NotImplementedError }
 
-    specify { expect(subject).to be < described_class::BaseError }
+    specify { expect(errors).to be < described_class::BaseError }
   end
 end

data/spec/lib/polish_geeks/dev_tools/hash_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 RSpec.describe PolishGeeks::DevTools::Hash do
   describe 'same_key_structure?' do
-    subject { h1.same_key_structure?(h2) }
+    subject(:hash) { h1.same_key_structure?(h2) }
 
     context 'when both are empty' do
       let(:h1) { described_class.new }
       let(:h2) { described_class.new }
 
-      it { expect(subject).to be true }
+      it { expect(hash).to be true }
     end
 
     context 'when first hash is not equal to second' do
@@ -16,14 +16,14 @@ RSpec.describe PolishGeeks::DevTools::Hash do
         let(:h1) { described_class.new.merge(a: 1) }
         let(:h2) { described_class.new.merge(b: 1) }
 
-        it { expect(subject).to be false }
+        it { expect(hash).to be false }
       end
 
       context 'on the second level' do
         let(:h1) { described_class.new.merge(a: { b: 2 }) }
         let(:h2) { described_class.new.merge(a: { c: 3 }) }
 
-        it { expect(subject).to be false }
+        it { expect(hash).to be false }
       end
     end
 
@@ -31,7 +31,7 @@ RSpec.describe PolishGeeks::DevTools::Hash do
       let(:h1) { described_class.new.merge(a: { b: rand }) }
       let(:h2) { described_class.new.merge(a: { b: rand }) }
 
-      it { expect(subject).to be true }
+      it { expect(hash).to be true }
     end
   end
 end

data/spec/lib/polish_geeks/dev_tools/logger_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 RSpec.describe PolishGeeks::DevTools::Logger do
-  subject { described_class.new }
+  subject(:logger) { described_class.new }
 
   let(:task) { PolishGeeks::DevTools::Commands::Rubocop.new }
   let(:tmp) { double }
@@ -15,13 +15,13 @@ RSpec.describe PolishGeeks::DevTools::Logger do
         expect(tmp)
           .to receive(:generator?)
           .and_return(true)
-        expect(subject)
+        expect(logger)
           .to receive(:info)
           .with(task)
       end
 
       it 'returns some information' do
-        subject.log(task)
+        logger.log(task)
       end
     end
 
@@ -36,13 +36,13 @@ RSpec.describe PolishGeeks::DevTools::Logger do
         expect(tmp)
           .to receive(:valid?)
           .and_return(false)
-        expect(subject)
+        expect(logger)
           .to receive(:fatal)
           .with(tmp)
       end
 
       it 'raises RequirementsError' do
-        expect { subject.log(tmp) }
+        expect { logger.log(tmp) }
           .to raise_error PolishGeeks::DevTools::Errors::RequirementsError
       end
     end
@@ -69,10 +69,10 @@ RSpec.describe PolishGeeks::DevTools::Logger do
       end
 
       it 'displays "OK" text' do
-        expect(subject)
+        expect(logger)
           .to receive(:printf)
           .with('%-50s %2s', 'Rubocop ', "\e[32mOK\e[0m\n")
-        subject.send(:info, task)
+        logger.send(:info, task)
       end
     end
 
@@ -96,10 +96,10 @@ RSpec.describe PolishGeeks::DevTools::Logger do
       end
 
       it 'displays "OK" text' do
-        expect(subject)
+        expect(logger)
           .to receive(:printf)
           .with('%-50s %2s', 'Rubocop ', "\e[32mGENERATED\e[0m\n")
-        subject.send(:info, task)
+        logger.send(:info, task)
       end
     end
 
@@ -120,7 +120,7 @@ RSpec.describe PolishGeeks::DevTools::Logger do
       end
 
       it 'raises UnknownTaskType' do
-        expect { subject.send(:info, tmp) }
+        expect { logger.send(:info, tmp) }
           .to raise_error PolishGeeks::DevTools::Errors::UnknownTaskType
       end
     end
@@ -138,10 +138,10 @@ RSpec.describe PolishGeeks::DevTools::Logger do
       end
 
       it 'returns a message' do
-        expect(subject)
+        expect(logger)
           .to receive(:printf)
           .with('%-30s %20s', 'Rubocop ', "\e[31mFAILURE\e[0m\n\n")
-        subject.send(:fatal, task)
+        logger.send(:fatal, task)
       end
     end
   end
@@ -155,7 +155,7 @@ RSpec.describe PolishGeeks::DevTools::Logger do
       end
 
       it 'returns the label' do
-        expect(subject.send(:label, task)).to eq 'Rubocop'
+        expect(logger.send(:label, task)).to eq 'Rubocop'
       end
     end
   end