sabat-guard-rubocop 0.1.1

data/CHANGELOG.md

@@ -0,0 +1,26 @@
+# CHANGELOG
+
+## v0.1.0
+
+* Update RuboCop dependency to 0.9 or later and earlier than 1.0
+* Rework with JSON formatter
+* Change the displayed text to "Inspecting ..."
+* Print relative file paths when they are under current working directory
+
+## v0.0.4
+
+* Specify dependency on rubocop gem as under 0.9.0
+* Force RuboCop to colorize output even though output is not TTY
+* Revert "Use rubocop 0.6.1 --no-color option instead of uncoloring colored output"
+
+## v0.0.3
+
+* Use rubocop 0.6.1 --no-color option instead of uncoloring colored output
+
+## v0.0.2
+
+* Fix capitalization of the name RuboCop in notification title
+
+## v0.0.1
+
+* Initial release

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'coveralls',      '~> 0.6'
+  gem 'simplecov-rcov', '~> 0.2'
+  gem 'ci_reporter',    '~> 1.8'
+end

data/Guardfile

@@ -0,0 +1,14 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec, all_after_pass: true, all_on_start: true, keep_failed: true do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})        { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')     { "spec" }
+  watch(%r{^spec/support/.+\.rb$}) { "spec" }
+end
+
+guard :rubocop do
+  watch(%r{.+\.rb$})
+  watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.dirname(m[0]) }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Yuji Nakayama
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,71 @@
+[![Gem Version](https://badge.fury.io/rb/guard-rubocop.png)](http://badge.fury.io/rb/guard-rubocop) [![Dependency Status](https://gemnasium.com/yujinakayama/guard-rubocop.png)](https://gemnasium.com/yujinakayama/guard-rubocop) [![Build Status](https://travis-ci.org/yujinakayama/guard-rubocop.png?branch=master)](https://travis-ci.org/yujinakayama/guard-rubocop) [![Coverage Status](https://coveralls.io/repos/yujinakayama/guard-rubocop/badge.png?branch=master)](https://coveralls.io/r/yujinakayama/guard-rubocop) [![Code Climate](https://codeclimate.com/github/yujinakayama/guard-rubocop.png)](https://codeclimate.com/github/yujinakayama/guard-rubocop)
+
+# Guard::Rubocop
+
+Guard::Rubocop allows you to automatically check Ruby code style with [RuboCop](https://github.com/bbatsov/rubocop) when files are modified.
+
+Tested on MRI 1.9 and MRI 2.0, according to RuboCop.
+
+## Installation
+
+Please make sure to have [Guard](https://github.com/guard/guard) installed before continue.
+
+Add `guard-rubocop` to your `Gemfile`:
+
+```ruby
+group :development do
+  gem 'guard-rubocop'
+end
+```
+
+and then execute:
+
+```sh
+$ bundle install
+```
+
+or install it yourself as:
+
+```sh
+$ gem install guard-rubocop
+```
+
+Add the default Guard::Rubocop definition to your `Guardfile` by running:
+
+```sh
+$ guard init rubocop
+```
+
+## Usage
+
+Please read the [Guard usage documentation](https://github.com/guard/guard#readme).
+
+## Options
+
+You can pass some options in `Guardfile`:
+
+```ruby
+guard :rubocop, all_on_start: false, notification: true do
+  # ...
+end
+```
+
+### Available Options
+
+```ruby
+all_on_start: true     # Check all files at Guard startup, default: true
+keep_failed: true      # Keep failed files until they pass, default: true
+notification: :failed  # Display Growl notification after each run
+                       #   true    - Always notify
+                       #   false   - Never notify
+                       #   :failed - Notify only when failed
+                       #   default: :failed
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,18 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :ci do
+  task :spec do
+    ENV['CI'] = 'true'
+
+    ENV['CI_REPORTS'] = 'spec/reports'
+    require 'ci/reporter/rake/rspec'
+    Rake::Task['ci:setup:rspec'].invoke
+
+    Rake::Task['spec'].invoke
+  end
+end
+
+task default: :spec

data/guard-rubocop.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'guard/rubocop/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'sabat-guard-rubocop'
+  spec.version       = Guard::RubocopVersion::VERSION
+  spec.authors       = ['Yuji Nakayama']
+  spec.email         = ['nkymyj@gmail.com']
+  spec.summary       = 'Guard plugin for RuboCop'
+  spec.description   = 'Guard::Rubocop automatically checks Ruby code style with RuboCop when files are modified.'
+  spec.homepage      = 'https://github.com/sabat/guard-rubocop'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/).reject { |f| File.basename(f).start_with?('.') }
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'guard',   '~> 1.8'
+  spec.add_runtime_dependency 'sabat-rubocop', '~> 0.9'
+
+  spec.add_development_dependency 'bundler',     '~> 1.3'
+  spec.add_development_dependency 'rake',        '~> 10.0'
+  spec.add_development_dependency 'rspec',       '~> 2.13'
+  spec.add_development_dependency 'simplecov',   '~> 0.7'
+  spec.add_development_dependency 'guard-rspec', '~> 3.0'
+  spec.add_development_dependency 'ruby_gntp',   '~> 0.3'
+end

data/lib/guard/rubocop.rb

@@ -0,0 +1,85 @@
+# coding: utf-8
+
+require 'guard'
+require 'guard/guard'
+
+module Guard
+  class Rubocop < Guard
+    autoload :Runner, 'guard/rubocop/runner'
+
+    attr_reader :options, :failed_paths
+
+    def initialize(watchers = [], options = {})
+      super
+
+      @options = {
+        all_on_start: true,
+        keep_failed:  true,
+        notification: :failed
+      }.merge(options)
+
+      @failed_paths = []
+    end
+
+    def start
+      run_all if @options[:all_on_start]
+    end
+
+    def run_all
+      UI.info 'Inspecting Ruby code style of all files'
+      run
+    end
+
+    def run_on_changes(paths)
+      paths += @failed_paths if @options[:keep_failed]
+      paths = clean_paths(paths)
+
+      displayed_paths = paths.map { |path| smart_path(path) }
+      UI.info "Inspecting Ruby code style: #{displayed_paths.join(' ')}"
+
+      run(paths)
+    end
+
+    def reload
+      @failed_paths = []
+    end
+
+    def clean_paths(paths)
+      paths = paths.dup
+      paths.map! { |path| File.expand_path(path) }
+      paths.uniq!
+      paths.reject! do |path|
+        included_in_other_path?(path, paths)
+      end
+      paths
+    end
+
+    private
+
+    def run(paths = [])
+      runner = Runner.new(@options)
+      passed = runner.run(paths)
+      @failed_paths = runner.failed_paths
+      throw :task_has_failed unless passed
+    rescue => error
+      UI.error 'The following exception occurred while running guard-rubocop: ' +
+               "#{error.backtrace.first} #{error.message} (#{error.class.name})"
+    end
+
+    def included_in_other_path?(target_path, other_paths)
+      dir_paths = other_paths.select { |path| File.directory?(path) }
+      dir_paths.delete(target_path)
+      dir_paths.any? do |dir_path|
+        target_path.start_with?(dir_path)
+      end
+    end
+
+    def smart_path(path)
+      if path.start_with?(Dir.pwd)
+        Pathname.new(path).relative_path_from(Pathname.getwd).to_s
+      else
+        path
+      end
+    end
+  end
+end

data/lib/guard/rubocop/runner.rb

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+require 'json'
+
+module Guard
+  class Rubocop
+    class Runner
+      def initialize(options)
+        @options = options
+      end
+
+      def run(paths = [])
+        command = build_command(paths)
+        passed = system(*command)
+
+        case @options[:notification]
+        when :failed
+          notify(passed) unless passed
+        when true
+          notify(passed)
+        end
+
+        passed
+      end
+
+      def build_command(paths)
+        command = ['rubocop']
+        command.concat(%w(--format progress)) # Keep default formatter for console.
+        command.concat(['--format', 'json', '--out', json_file_path])
+        command.concat(['--list-cops']) if @options[:cops]
+        command.concat(paths)
+      end
+
+      def json_file_path
+        @tempfile_path ||= begin
+          # Just generate random tempfile path.
+          basename = self.class.name.downcase.gsub('::', '_')
+          tempfile = Tempfile.new(basename)
+          tempfile.close
+          tempfile.path
+        end
+      end
+
+      def result
+        @result ||= begin
+          File.open(json_file_path) do |file|
+            # Rubinius 2.0.0.rc1 does not support `JSON.load` with 3 args.
+            JSON.parse(file.read, symbolize_names: true)
+          end
+        end
+      end
+
+      def notify(passed)
+        image = passed ? :success : :failed
+        Notifier.notify(summary_text, title: 'RuboCop results', image: image)
+      end
+
+      def summary_text
+        summary = result[:summary]
+
+        text = pluralize(summary[:inspected_file_count], 'file')
+        text << ' inspected, '
+
+        text << pluralize(summary[:offence_count], 'offence', no_for_zero: true)
+        text << ' detected'
+      end
+
+      def failed_paths
+        failed_files = result[:files].reject do |file|
+          file[:offences].empty?
+        end
+        failed_files.map do |file|
+          file[:path]
+        end
+      end
+
+      def pluralize(number, thing, options = {})
+        text = ''
+
+        if number == 0 && options[:no_for_zero]
+          text = 'no'
+        else
+          text << number.to_s
+        end
+
+        text << " #{thing}"
+        text << 's' unless number == 1
+
+        text
+      end
+    end
+  end
+end

data/lib/guard/rubocop/templates/Guardfile

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

data/lib/guard/rubocop/version.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+
+module Guard
+  # A workaround for declaring `class Rubocop`
+  # before `class Rubocop < Guard` in rubocop.rb
+  module RubocopVersion
+    # http://semver.org/
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 1
+    VERSION = [MAJOR, MINOR, PATCH].join('.')
+  end
+end

data/spec/guard/rubocop/runner_spec.rb

@@ -0,0 +1,302 @@
+# coding: utf-8
+
+require 'spec_helper.rb'
+
+describe Guard::Rubocop::Runner do
+  subject(:runner) { Guard::Rubocop::Runner.new(options) }
+  let(:options) { {} }
+
+  describe '#run' do
+    subject { super().run(paths) }
+    let(:paths) { ['spec/spec_helper.rb'] }
+
+    before do
+      runner.stub(:system)
+    end
+
+    it 'executes rubocop' do
+      runner.should_receive(:system) do |*args|
+        args.first.should == 'rubocop'
+      end
+      runner.run
+    end
+
+    context 'when RuboCop exited with 0 status' do
+      before do
+        runner.stub(:system).and_return(true)
+      end
+      it { should be_true }
+    end
+
+    context 'when RuboCop exited with non 0 status' do
+      before do
+        runner.stub(:system).and_return(false)
+      end
+      it { should be_false }
+    end
+
+    shared_examples 'notifies', :notifies do
+      it 'notifies' do
+        runner.should_receive(:notify)
+        runner.run
+      end
+    end
+
+    shared_examples 'does not notify', :does_not_notify do
+      it 'does not notify' do
+        runner.should_not_receive(:notify)
+        runner.run
+      end
+    end
+
+    shared_examples 'notification' do |expectations|
+      context 'when passed' do
+        before do
+          runner.stub(:system).and_return(true)
+        end
+
+        if expectations[:passed]
+          include_examples 'notifies'
+        else
+          include_examples 'does not notify'
+        end
+      end
+
+      context 'when failed' do
+        before do
+          runner.stub(:system).and_return(false)
+        end
+
+        if expectations[:failed]
+          include_examples 'notifies'
+        else
+          include_examples 'does not notify'
+        end
+      end
+    end
+
+    context 'when :notification option is true' do
+      let(:options) { { notification: 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 }
+    end
+
+    context 'when :notification option is false' do
+      let(:options) { { notification: false } }
+      include_examples 'notification', { passed: false, failed: false }
+    end
+
+    context 'when :cops option is true' do
+      let(:options) { { cops: true } }
+
+    end
+  end
+
+  describe '#build_command' do
+    let(:paths) { %w(file1.rb file2.rb) }
+
+    it 'adds args for the default formatter for console' do
+      runner.build_command(paths)[0..2].should == %w(rubocop --format progress)
+    end
+
+    it 'adds args for JSON formatter ' do
+      runner.build_command(paths)[3..4].should == %w(--format json)
+    end
+
+    it 'adds args for output file path of JSON formatter ' do
+      command = runner.build_command(paths)
+      command[5].should == '--out'
+      command[6].should_not be_empty
+    end
+
+    context 'cops option is set' do
+      let(:options) { { cops: true } }
+
+      it 'adds the --list-cops flag' do
+        command = runner.build_command(paths)
+        command[7].should == '--list-cops'
+      end
+    end
+
+    it 'adds the passed paths' do
+      runner.build_command(paths)[7..-1].should == %w(file1.rb file2.rb)
+    end
+  end
+
+  describe '#json_file_path' do
+    it 'is not world readable' do
+      File.world_readable?(runner.json_file_path).should be_false
+    end
+  end
+
+  shared_context 'JSON file', :json_file do
+    before do
+      json = <<-END
+        {
+          "metadata": {
+            "rubocop_version": "0.9.0",
+            "ruby_engine": "ruby",
+            "ruby_version": "2.0.0",
+            "ruby_patchlevel": "195",
+            "ruby_platform": "x86_64-darwin12.3.0"
+          },
+          "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
+                  }
+                }
+              ]
+            }
+          ],
+          "summary": {
+            "offence_count": 2,
+            "target_file_count": 2,
+            "inspected_file_count": 2
+          }
+        }
+      END
+      File.write(runner.json_file_path, json)
+    end
+  end
+
+  describe '#result', :json_file do
+    it 'parses JSON file' do
+      runner.result[:summary][:offence_count].should == 2
+    end
+  end
+
+  describe '#notify' do
+    before do
+      runner.stub(:result).and_return(
+        {
+          summary: {
+            offence_count: 4,
+            target_file_count: 3,
+            inspected_file_count: 2
+          }
+        }
+      )
+    end
+
+    it 'notifies summary' do
+      Guard::Notifier.should_receive(:notify) do |message, options|
+        message.should == '2 files inspected, 4 offences detected'
+      end
+      runner.notify(true)
+    end
+
+    it 'notifies with title "RuboCop results"' do
+      Guard::Notifier.should_receive(:notify) do |message, options|
+        options[:title].should == 'RuboCop results'
+      end
+      runner.notify(true)
+    end
+
+    context 'when passed' do
+      it 'shows success image' do
+        Guard::Notifier.should_receive(:notify) do |message, options|
+          options[:image].should == :success
+        end
+        runner.notify(true)
+      end
+    end
+
+    context 'when failed' do
+      it 'shows failed image' do
+        Guard::Notifier.should_receive(:notify) do |message, options|
+          options[:image].should == :failed
+        end
+        runner.notify(false)
+      end
+    end
+  end
+
+  describe '#summary_text' do
+    before do
+      runner.stub(:result).and_return(
+        {
+          summary: {
+            offence_count: offence_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(:target_file_count)    { 0 }
+    let(:inspected_file_count) { 0 }
+
+    context 'when no files are inspected' do
+      let(:inspected_file_count) { 0 }
+      it 'includes "0 files"' do
+        summary_text.should include '0 files'
+      end
+    end
+
+    context 'when a file is inspected' do
+      let(:inspected_file_count) { 1 }
+      it 'includes "1 file"' do
+        summary_text.should include '1 file'
+      end
+    end
+
+    context 'when 2 files are inspected' do
+      let(:inspected_file_count) { 2 }
+      it 'includes "2 files"' do
+        summary_text.should include '2 files'
+      end
+    end
+
+    context 'when no offences are detected' do
+      let(:offence_count) { 0 }
+      it 'includes "no offences"' do
+        summary_text.should include 'no offences'
+      end
+    end
+
+    context 'when an offence is detected' do
+      let(:offence_count) { 1 }
+      it 'includes "1 offence"' do
+        summary_text.should include '1 offence'
+      end
+    end
+
+    context 'when 2 offences are detected' do
+      let(:offence_count) { 2 }
+      it 'includes "2 offences"' do
+        summary_text.should include '2 offences'
+      end
+    end
+  end
+
+  describe '#failed_paths', :json_file do
+    it 'returns file paths which have offences' do
+      runner.failed_paths.should == ['lib/bar.rb']
+    end
+  end
+end

data/spec/guard/rubocop_spec.rb

@@ -0,0 +1,202 @@
+# coding: utf-8
+
+require 'spec_helper.rb'
+
+describe Guard::Rubocop, :silence_output do
+  subject(:guard) { Guard::Rubocop.new(watchers, options) }
+  let(:watchers) { [] }
+  let(:options) { {} }
+
+  let(:runner) { Guard::Rubocop::Runner.any_instance }
+
+  describe '#options' do
+    subject { super().options }
+
+    context 'by default' do
+      let(:options) { {} }
+      its([:all_on_start]) { should be_true }
+      its([:keep_failed])  { should be_true }
+      its([:notification]) { should == :failed }
+      its([:cops])         { should be_false }
+    end
+  end
+
+  describe '#start' do
+    context 'when :all_on_start option is enabled' do
+      let(:options) { { all_on_start: true } }
+
+      it 'runs all' do
+        guard.should_receive(:run_all)
+        guard.start
+      end
+    end
+
+    context 'when :all_on_start option is disabled' do
+      let(:options) { { all_on_start: false } }
+
+      it 'does nothing' do
+        guard.should_not_receive(:run_all)
+        guard.start
+      end
+    end
+  end
+
+  shared_examples 'processes after running', :processes_after_running do
+    context 'when passed' do
+      it 'throws nothing' do
+        runner.stub(:run).and_return(true)
+        expect { subject }.not_to throw_symbol
+      end
+
+      it 'clears failed paths' do
+        runner.stub(:run).and_return(true)
+        runner.stub(:failed_paths).and_return([])
+        subject
+        guard.failed_paths.should be_empty
+      end
+    end
+
+    context 'when failed' do
+      it 'throws symbol :task_has_failed' do
+        runner.stub(:run).and_return(false)
+        expect { subject }.to throw_symbol(:task_has_failed)
+      end
+
+      it 'keeps failed paths' do
+        guard.stub(:throw)
+        failed_paths = [
+          'some_failed_file.rb',
+          'dir/another_failed_file.rb'
+        ]
+        runner.stub(:run).and_return(false)
+        runner.stub(:failed_paths).and_return(failed_paths)
+        subject
+        guard.failed_paths.should == failed_paths
+      end
+    end
+
+    context 'when an exception is raised' do
+      it 'prevents itself from firing' do
+        runner.stub(:run).and_raise(RuntimeError)
+        expect { subject }.not_to raise_error
+      end
+    end
+  end
+
+  describe '#run_all', :processes_after_running do
+    subject { super().run_all }
+
+    before do
+      runner.stub(:run).and_return(true)
+      runner.stub(:failed_paths).and_return([])
+    end
+
+    it 'inspects all files with rubocop' do
+      runner.should_receive(:run).with([])
+      guard.run_all
+    end
+  end
+
+  describe '#run_on_changes', :processes_after_running do
+    subject { super().run_on_changes(changed_paths) }
+    let(:changed_paths) { ['some.rb', 'dir/another.rb', 'dir/../some.rb'] }
+
+    before do
+      runner.stub(:run).and_return(true)
+      runner.stub(:failed_paths).and_return([])
+    end
+
+    it 'inspects changed files with rubocop' do
+      runner.should_receive(:run)
+      guard.run_on_changes(changed_paths)
+    end
+
+    it 'passes cleaned paths to rubocop' do
+      runner.should_receive(:run) do |paths|
+        paths.should == [
+          File.expand_path('some.rb'),
+          File.expand_path('dir/another.rb')
+        ]
+      end
+      guard.run_on_changes(changed_paths)
+    end
+
+    let(:failed_path) { File.expand_path('failed_file_last_time.rb') }
+
+    context 'when :keep_failed option is enabled' do
+      let(:options) { { keep_failed: true } }
+
+      it 'also inspects paths which are failed last time' do
+        guard.failed_paths << failed_path
+        runner.should_receive(:run) do |paths|
+          paths.should include failed_path
+        end
+        guard.run_on_changes(changed_paths)
+      end
+    end
+
+    context 'when :keep_failed option is disabled' do
+      let(:options) { { keep_failed: false } }
+      let(:changed_paths) do
+        [
+          File.expand_path('some.rb'),
+          File.expand_path('dir/another.rb')
+        ]
+      end
+
+      it 'inspects just changed paths' do
+        guard.failed_paths << failed_path
+        runner.should_receive(:run) do |paths|
+          paths.should == changed_paths
+        end
+        guard.run_on_changes(changed_paths)
+      end
+    end
+  end
+
+  describe '#reload' do
+    it 'clears failed paths' do
+      guard.failed_paths << 'failed.rb'
+      guard.reload
+      guard.failed_paths.should be_empty
+    end
+  end
+
+  describe '#clean_paths' do
+    it 'converts to absolute paths' do
+      paths = [
+        'lib/guard/rubocop.rb',
+        'spec/spec_helper.rb'
+      ]
+      guard.clean_paths(paths).should == [
+        File.expand_path('lib/guard/rubocop.rb'),
+        File.expand_path('spec/spec_helper.rb')
+      ]
+    end
+
+    it 'removes duplicated paths' do
+      paths = [
+        'lib/guard/rubocop.rb',
+        'spec/spec_helper.rb',
+        'lib/guard/../guard/rubocop.rb'
+      ]
+      guard.clean_paths(paths).should == [
+        File.expand_path('lib/guard/rubocop.rb'),
+        File.expand_path('spec/spec_helper.rb')
+      ]
+    end
+
+    it 'removes paths which are included in another path' do
+      paths = [
+        'lib/guard/rubocop.rb',
+        'spec/spec_helper.rb',
+        'spec'
+      ]
+      guard.clean_paths(paths).should == [
+        File.expand_path('lib/guard/rubocop.rb'),
+        File.expand_path('spec')
+      ]
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+# coding: utf-8
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+end
+
+Dir[File.join(File.dirname(__FILE__), 'support', '*')].each do |path|
+  require path
+end
+
+require 'simplecov'
+SimpleCov.coverage_dir(File.join('spec', 'coverage'))
+
+if ENV['TRAVIS']
+  require 'coveralls'
+  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+elsif ENV['CI'] # rubocop:disable IfUnlessModifier
+  require 'simplecov-rcov'
+  SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
+end
+
+SimpleCov.start do
+  add_filter '/spec/'
+  add_filter '/vendor/bundle/'
+end
+
+require 'guard/rubocop'

data/spec/support/silence_output.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+
+shared_context 'silence output', silence_output: true do
+  before do
+    null_output = double('output').as_null_object
+
+    @original_stdout = $stdout
+    @original_stderr = $stderr
+
+    $stdout = null_output
+    $stderr = null_output
+  end
+
+  after do
+    $stdout = @original_stdout
+    $stderr = @original_stderr
+  end
+end

metadata

@@ -0,0 +1,195 @@
+--- !ruby/object:Gem::Specification
+name: sabat-guard-rubocop
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Yuji Nakayama
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: sabat-rubocop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: ruby_gntp
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+description: Guard::Rubocop automatically checks Ruby code style with RuboCop when
+  files are modified.
+email:
+- nkymyj@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- guard-rubocop.gemspec
+- lib/guard/rubocop.rb
+- lib/guard/rubocop/runner.rb
+- lib/guard/rubocop/templates/Guardfile
+- lib/guard/rubocop/version.rb
+- spec/guard/rubocop/runner_spec.rb
+- spec/guard/rubocop_spec.rb
+- spec/spec_helper.rb
+- spec/support/silence_output.rb
+homepage: https://github.com/sabat/guard-rubocop
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Guard plugin for RuboCop
+test_files:
+- spec/guard/rubocop/runner_spec.rb
+- spec/guard/rubocop_spec.rb
+- spec/spec_helper.rb
+- spec/support/silence_output.rb
+has_rdoc: