guard-rubocop 1.0.1 → 1.4.0

data/lib/guard/rubocop/templates/Guardfile

@@ -1,4 +1,4 @@
 guard :rubocop do
   watch(%r{.+\.rb$})
-  watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.dirname(m[0]) }
+  watch(%r{(?:.+/)?\.rubocop(?:_todo)?\.yml$}) { |m| File.dirname(m[0]) }
 end

data/lib/guard/rubocop/version.rb

@@ -1,16 +1,14 @@
-# coding: utf-8
+# frozen_string_literal: true
 
-module Guard
-  # A workaround for declaring `class Rubocop`
-  # before `class Rubocop < Guard` in rubocop.rb
-  module RubocopVersion
-    # http://semver.org/
-    MAJOR = 1
-    MINOR = 0
-    PATCH = 1
+# A workaround for declaring `class RuboCop`
+# before `class RuboCop < Guard` in rubocop.rb
+module GuardRuboCopVersion
+  # http://semver.org/
+  MAJOR = 1
+  MINOR = 4
+  PATCH = 0
 
-    def self.to_s
-      [MAJOR, MINOR, PATCH].join('.')
-    end
+  def self.to_s
+    [MAJOR, MINOR, PATCH].join('.')
   end
 end

data/spec/guard/rubocop/runner_spec.rb

@@ -1,9 +1,9 @@
-# coding: utf-8
+# frozen_string_literal: true
 
-require 'spec_helper.rb'
+require 'launchy'
 
-describe Guard::Rubocop::Runner do
-  subject(:runner) { Guard::Rubocop::Runner.new(options) }
+RSpec.describe Guard::RuboCop::Runner do
+  subject(:runner) { Guard::RuboCop::Runner.new(options) }
   let(:options) { {} }
 
   describe '#run' do
@@ -25,14 +25,14 @@ describe Guard::Rubocop::Runner do
       before do
         allow(runner).to receive(:system).and_return(true)
       end
-      it { should be_true }
+      it { should be_truthy }
     end
 
     context 'when RuboCop exited with non 0 status' do
       before do
         allow(runner).to receive(:system).and_return(false)
       end
-      it { should be_false }
+      it { should be_falsey }
     end
 
     shared_examples 'notifies', :notifies do
@@ -77,56 +77,95 @@ describe Guard::Rubocop::Runner do
 
     context 'when :notification option is true' do
       let(:options) { { notification: true } }
-      include_examples 'notification', { passed: true, failed: true }
+      include_examples 'notification', passed: true, failed: true
     end
 
     context 'when :notification option is :failed' do
       let(:options) { { notification: :failed } }
-      include_examples 'notification', { passed: false, failed: true }
+      include_examples 'notification', passed: false, failed: true
     end
 
     context 'when :notification option is false' do
       let(:options) { { notification: false } }
-      include_examples 'notification', { passed: false, failed: false }
+      include_examples 'notification', passed: false, failed: false
+    end
+
+    context 'when :launchy option is present' do
+      let(:options) { { launchy: 'launchy_path' } }
+
+      before do
+        allow(File).to receive(:exist?).with('launchy_path').and_return(true)
+      end
+
+      it 'opens Launchy' do
+        expect(Launchy).to receive(:open).with('launchy_path')
+        runner.run(paths)
+      end
     end
   end
 
   describe '#build_command' do
     subject(:build_command) { runner.build_command(paths) }
-    let(:options) { { cli: %w(--debug --rails) } }
-    let(:paths) { %w(file1.rb file2.rb) }
+    let(:options) { { cli: %w[--debug --rails] } }
+    let(:paths) { %w[file1.rb file2.rb] }
 
-    context 'when :cli option includes formatter for console' do
-      let(:options) { { cli: %w(--format simple) } }
+    context 'when :hide_stdout is not set' do
+      context 'and :cli option includes formatter for console' do
+        before { options[:cli] = %w[--format simple] }
 
-      it 'does not add args for the default formatter for console' do
-        expect(build_command[0..2]).not_to eq(%w(rubocop --format progress))
+        it 'does not add args for the default formatter for console' do
+          expect(build_command[0..2]).not_to eq(%w[rubocop --format progress])
+        end
+      end
+
+      context 'and :cli option does not include formatter for console' do
+        before { options[:cli] = %w[--format simple --out simple.txt] }
+
+        it 'adds args for the default formatter for console' do
+          expect(build_command[0..2]).to eq(%w[rubocop --format progress])
+        end
       end
     end
 
-    context 'when :cli option does not include formatter for console' do
-      let(:options) { { cli: %w(--format simple --out simple.txt) } }
+    context 'when :hide_stdout is set' do
+      before { options[:hide_stdout] = true }
+
+      context 'and :cli option includes formatter for console' do
+        before { options[:cli] = %w[--format simple] }
+
+        it 'does not add args for the default formatter for console' do
+          expect(build_command[0..2]).not_to eq(%w[rubocop --format progress])
+        end
+      end
+
+      context 'and :cli option does not include formatter for console' do
+        before { options[:cli] = %w[--format simple --out simple.txt] }
 
-      it 'adds args for the default formatter for console' do
-        expect(build_command[0..2]).to eq(%w(rubocop --format progress))
+        it 'does not add args for the default formatter for console' do
+          expect(build_command[0..2]).not_to eq(%w[rubocop --format progress])
+        end
       end
     end
 
-    it 'adds args for JSON formatter ' do
-      expect(build_command[3..4]).to eq(%w(--format json))
+    it 'adds args for JSON formatter' do
+      expect(build_command[3..4]).to eq(%w[--format json])
     end
 
-    it 'adds args for output file path of JSON formatter ' do
+    it 'adds args for output file path of JSON formatter' do
       expect(build_command[5]).to eq('--out')
       expect(build_command[6]).not_to be_empty
     end
 
+    it 'adds --force-exclusion option' do
+      expect(build_command[7]).to eq('--force-exclusion')
+    end
+
     it 'adds args specified by user' do
-      expect(build_command[7..8]).to eq(%w(--debug --rails))
+      expect(build_command[8..9]).to eq(%w[--debug --rails])
     end
 
     it 'adds the passed paths' do
-      expect(build_command[9..-1]).to eq(%w(file1.rb file2.rb))
+      expect(build_command[10..-1]).to eq(%w[file1.rb file2.rb])
     end
   end
 
@@ -159,7 +198,7 @@ describe Guard::Rubocop::Runner do
       let(:options) { { cli: { key: 'value' } } }
 
       it 'raises error' do
-        expect { runner.args_specified_by_user }.to raise_error
+        expect { runner.args_specified_by_user }.to raise_error(ArgumentError)
       end
     end
   end
@@ -169,86 +208,86 @@ describe Guard::Rubocop::Runner do
 
     context 'when the passed args include a -f/--format' do
       context 'but does not include an -o/--output' do
-        let(:args) { %w(--format simple --debug) }
+        let(:args) { %w[--format simple --debug] }
 
         it 'returns true' do
-          expect(include_formatter_for_console?).to be_true
+          expect(include_formatter_for_console?).to be_truthy
         end
       end
 
       context 'and include an -o/--output just after the -f/--format' do
-        let(:args) { %w(--format simple --out simple.txt) }
+        let(:args) { %w[--format simple --out simple.txt] }
 
         it 'returns false' do
-          expect(include_formatter_for_console?).to be_false
+          expect(include_formatter_for_console?).to be_falsey
         end
       end
 
       context 'and include an -o/--output after the -f/--format across another arg' do
-        let(:args) { %w(--format simple --debug --out simple.txt) }
+        let(:args) { %w[--format simple --debug --out simple.txt] }
 
         it 'returns false' do
-          expect(include_formatter_for_console?).to be_false
+          expect(include_formatter_for_console?).to be_falsey
         end
       end
     end
 
     context 'when the passed args include a -f with its arg without separator' do
       context 'but does not include an -o/--output' do
-        let(:args) { %w(-fs --debug) }
+        let(:args) { %w[-fs --debug] }
 
         it 'returns true' do
-          expect(include_formatter_for_console?).to be_true
+          expect(include_formatter_for_console?).to be_truthy
         end
       end
 
       context 'and include an -o with its arg without separator just after the -f/--format' do
-        let(:args) { %w(-fs -osimple.txt) }
+        let(:args) { %w[-fs -osimple.txt] }
 
         it 'returns false' do
-          expect(include_formatter_for_console?).to be_false
+          expect(include_formatter_for_console?).to be_falsey
         end
       end
     end
 
     context 'when the passed args include multiple -f/--format' do
       context 'and all -f/--format have associated -o/--out' do
-        let(:args) { %w(--format simple --out simple.txt --format emacs --out emacs.txt) }
+        let(:args) { %w[--format simple --out simple.txt --format emacs --out emacs.txt] }
 
         it 'returns false' do
-          expect(include_formatter_for_console?).to be_false
+          expect(include_formatter_for_console?).to be_falsey
         end
       end
 
       context 'and any -f/--format has associated -o/--out' do
-        let(:args) { %w(--format simple --format emacs --out emacs.txt) }
+        let(:args) { %w[--format simple --format emacs --out emacs.txt] }
 
         it 'returns true' do
-          expect(include_formatter_for_console?).to be_true
+          expect(include_formatter_for_console?).to be_truthy
         end
       end
 
       context 'and no -f/--format has associated -o/--out' do
-        let(:args) { %w(--format simple --format emacs) }
+        let(:args) { %w[--format simple --format emacs] }
 
         it 'returns true' do
-          expect(include_formatter_for_console?).to be_true
+          expect(include_formatter_for_console?).to be_truthy
         end
       end
     end
 
     context 'when the passed args do not include -f/--format' do
-      let(:args) { %w(--debug) }
+      let(:args) { %w[--debug] }
 
       it 'returns false' do
-        expect(include_formatter_for_console?).to be_false
+        expect(include_formatter_for_console?).to be_falsey
       end
     end
   end
 
   describe '#json_file_path' do
     it 'is not world readable' do
-      expect(File.world_readable?(runner.json_file_path)).to be_false
+      expect(File.world_readable?(runner.json_file_path)).to be_falsey
     end
   end
 
@@ -265,10 +304,10 @@ describe Guard::Rubocop::Runner do
           },
           "files": [{
               "path": "lib/foo.rb",
-              "offences": []
+              "offenses": []
             }, {
               "path": "lib/bar.rb",
-              "offences": [{
+              "offenses": [{
                   "severity": "convention",
                   "message": "Line is too long. [81/79]",
                   "cop_name": "LineLength",
@@ -289,7 +328,7 @@ describe Guard::Rubocop::Runner do
             }
           ],
           "summary": {
-            "offence_count": 2,
+            "offense_count": 2,
             "target_file_count": 2,
             "inspected_file_count": 2
           }
@@ -301,32 +340,30 @@ describe Guard::Rubocop::Runner do
 
   describe '#result', :json_file do
     it 'parses JSON file' do
-      expect(runner.result[:summary][:offence_count]).to eq(2)
+      expect(runner.result[:summary][:offense_count]).to eq(2)
     end
   end
 
   describe '#notify' do
     before do
       allow(runner).to receive(:result).and_return(
-        {
-          summary: {
-            offence_count: 4,
-            target_file_count: 3,
-            inspected_file_count: 2
-          }
+        summary: {
+          offense_count: 4,
+          target_file_count: 3,
+          inspected_file_count: 2
         }
       )
     end
 
     it 'notifies summary' do
-      expect(Guard::Notifier).to receive(:notify) do |message, options|
-        expect(message).to eq('2 files inspected, 4 offences detected')
+      expect(Guard::Notifier).to receive(:notify) do |message, _options|
+        expect(message).to eq('2 files inspected, 4 offenses detected')
       end
       runner.notify(true)
     end
 
     it 'notifies with title "RuboCop results"' do
-      expect(Guard::Notifier).to receive(:notify) do |message, options|
+      expect(Guard::Notifier).to receive(:notify) do |_message, options|
         expect(options[:title]).to eq('RuboCop results')
       end
       runner.notify(true)
@@ -334,7 +371,7 @@ describe Guard::Rubocop::Runner do
 
     context 'when passed' do
       it 'shows success image' do
-        expect(Guard::Notifier).to receive(:notify) do |message, options|
+        expect(Guard::Notifier).to receive(:notify) do |_message, options|
           expect(options[:image]).to eq(:success)
         end
         runner.notify(true)
@@ -343,7 +380,7 @@ describe Guard::Rubocop::Runner do
 
     context 'when failed' do
       it 'shows failed image' do
-        expect(Guard::Notifier).to receive(:notify) do |message, options|
+        expect(Guard::Notifier).to receive(:notify) do |_message, options|
           expect(options[:image]).to eq(:failed)
         end
         runner.notify(false)
@@ -354,19 +391,17 @@ describe Guard::Rubocop::Runner do
   describe '#summary_text' do
     before do
       allow(runner).to receive(:result).and_return(
-        {
-          summary: {
-            offence_count: offence_count,
-            target_file_count: target_file_count,
-            inspected_file_count: inspected_file_count
-          }
+        summary: {
+          offense_count: offense_count,
+          target_file_count: target_file_count,
+          inspected_file_count: inspected_file_count
         }
       )
     end
 
     subject(:summary_text) { runner.summary_text }
 
-    let(:offence_count)        { 0 }
+    let(:offense_count)        { 0 }
     let(:target_file_count)    { 0 }
     let(:inspected_file_count) { 0 }
 
@@ -391,31 +426,86 @@ describe Guard::Rubocop::Runner do
       end
     end
 
-    context 'when no offences are detected' do
-      let(:offence_count) { 0 }
-      it 'includes "no offences"' do
-        expect(summary_text).to include 'no offences'
+    context 'when no offenses are detected' do
+      let(:offense_count) { 0 }
+      it 'includes "no offenses"' do
+        expect(summary_text).to include 'no offenses'
       end
     end
 
-    context 'when an offence is detected' do
-      let(:offence_count) { 1 }
-      it 'includes "1 offence"' do
-        expect(summary_text).to include '1 offence'
+    context 'when an offense is detected' do
+      let(:offense_count) { 1 }
+      it 'includes "1 offense"' do
+        expect(summary_text).to include '1 offense'
       end
     end
 
-    context 'when 2 offences are detected' do
-      let(:offence_count) { 2 }
-      it 'includes "2 offences"' do
-        expect(summary_text).to include '2 offences'
+    context 'when 2 offenses are detected' do
+      let(:offense_count) { 2 }
+      it 'includes "2 offenses"' do
+        expect(summary_text).to include '2 offenses'
+      end
+    end
+
+    context 'with spelling "offence" in old RuboCop' do
+      before do
+        allow(runner).to receive(:result).and_return(
+          summary: {
+            offence_count: 2,
+            target_file_count: 1,
+            inspected_file_count: 1
+          }
+        )
+      end
+
+      it 'handles the spelling' do
+        expect(summary_text).to include '2 offenses'
       end
     end
   end
 
   describe '#failed_paths', :json_file do
-    it 'returns file paths which have offences' do
+    it 'returns file paths which have offenses' do
       expect(runner.failed_paths).to eq(['lib/bar.rb'])
     end
+
+    context 'with spelling "offence" in old RuboCop' do
+      before do
+        json = <<-END
+          {
+            "files": [{
+                "path": "lib/foo.rb",
+                "offences": []
+              }, {
+                "path": "lib/bar.rb",
+                "offences": [{
+                    "severity": "convention",
+                    "message": "Line is too long. [81/79]",
+                    "cop_name": "LineLength",
+                    "location": {
+                      "line": 546,
+                      "column": 80
+                    }
+                  }, {
+                    "severity": "warning",
+                    "message": "Unreachable code detected.",
+                    "cop_name": "UnreachableCode",
+                    "location": {
+                      "line": 15,
+                      "column": 9
+                    }
+                  }
+                ]
+              }
+            ]
+          }
+        END
+        File.write(runner.json_file_path, json)
+      end
+
+      it 'handles the spelling' do
+        expect(runner.failed_paths).to eq(['lib/bar.rb'])
+      end
+    end
   end
 end