guard-rubocop 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b0043258943e6ce7804f19377ee96f8cb4fbe231
+  data.tar.gz: 63e9ca25fb5011528c2e86df4b1a98eccfda5e4a
+SHA512:
+  metadata.gz: 292b240599d027edd2125021b55212ae4f0291eaa7d897a4489d2cf8d338c8bb372480a344cc2e468e2f09a2ff941530921a1db8d9e6b66c681c2c30abe3f121
+  data.tar.gz: 052a46d2a3f6e4a2ba5abb368e0ff6cc91d3cad56bdb21d9e8de14f57a26106420833544c7fd204e7b943143f44c0ea4a242c30e38dfe1005506531be1b9af89

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+script: bundle exec rspec

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+gemspec
+
+# Travis CI
+group :test do
+  gem 'coveralls'
+end
+
+# Jenkins
+group :ci do
+  gem 'simplecov-rcov', '~> 0.2'
+end

data/Guardfile

@@ -0,0 +1,14 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' 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,70 @@
+# 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) [![Dependency Status](https://gemnasium.com/yujinakayama/guard-rubocop.png)](https://gemnasium.com/yujinakayama/guard-rubocop) [![Code Climate](https://codeclimate.com/github/yujinakayama/guard-rubocop.png)](https://codeclimate.com/github/yujinakayama/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 @@
+require "bundler/gem_tasks"

data/guard-rubocop.gemspec

@@ -0,0 +1,34 @@
+# 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          = "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 allows you to automatically check Ruby code style with RuboCop when files are modified."
+  spec.homepage      = "https://github.com/yujinakayama/guard-rubocop"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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 "rubocop",        "~> 0.5"
+  spec.add_runtime_dependency "childprocess",   "~> 0.3"
+  spec.add_runtime_dependency "term-ansicolor", "~> 1.1"
+
+  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", ">= 2.5.4"
+  spec.add_development_dependency "ruby_gntp",   ">= 0.3"
+end

data/lib/guard/.rubocop.yml

@@ -0,0 +1,4 @@
+# A workaround for `autoload :Runner` in rubocop.rb
+# until comment based switch will be released
+SymbolSnakeCase:
+  Enabled: false

data/lib/guard/rubocop.rb

@@ -0,0 +1,79 @@
+# coding: utf-8
+
+require 'guard'
+require 'guard/guard'
+require 'guard/notifier'
+
+module Guard
+  class Rubocop < Guard
+    # rubocop:disable SymbolSnakeCase
+    autoload :Runner, 'guard/rubocop/runner'
+    # rubocop:enable SymbolSnakeCase
+
+    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 'Checking Ruby code style of all files'
+
+      runner = Runner.new(@options)
+      passed = runner.run
+      @failed_paths = runner.failed_paths
+
+      throw :task_has_failed unless passed
+    end
+
+    def run_on_changes(paths)
+      paths += @failed_paths if @options[:keep_failed]
+      paths.map! { |path| File.expand_path(path) }
+      paths.uniq!
+
+      UI.info "Checking Ruby code styles: #{paths.join(' ')}"
+
+      runner = Runner.new(@options)
+      passed = runner.run(paths)
+      @failed_paths = runner.failed_paths
+
+      throw :task_has_failed unless passed
+    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 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
+  end
+end

data/lib/guard/rubocop/runner.rb

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+require 'childprocess'
+require 'term/ansicolor'
+
+module Guard
+  class Rubocop
+    class Runner
+      PASSED_EXIT_CODE = 0
+      MINIMUM_POLL_INTERVAL = 0.1
+
+      attr_reader :passed, :output
+
+      alias_method :passed?, :passed
+
+      def initialize(options)
+        @options = options
+      end
+
+      def run(paths = [])
+        exit_code, output = rubocop(paths)
+        @passed = (exit_code == PASSED_EXIT_CODE)
+        @output = Term::ANSIColor.uncolor(output)
+
+        case @options[:notification]
+        when :failed
+          notify unless passed?
+        when true
+          notify
+        end
+
+        passed
+      end
+
+      def rubocop(args)
+        process = ChildProcess.build('rubocop', *args)
+
+        stdout_reader, stdout_writer = IO.pipe
+        process.io.stdout = stdout_writer
+
+        process.start
+
+        ios = [stdout_reader]
+        output = ''
+
+        loop do
+          available_ios, = IO.select(ios, nil, nil, MINIMUM_POLL_INTERVAL)
+
+          if available_ios
+            available_ios.each do |io|
+              chunk = io.read_available_nonblock
+              $stdout.write chunk
+              output << chunk
+            end
+          end
+
+          break if process.exited?
+        end
+
+        [process.exit_code, output]
+      end
+
+      def notify
+        image = passed ? :success : :failed
+        Notifier.notify(summary, title: 'Rubocop results', image: image)
+      end
+
+      def summary
+        return nil unless output
+        output.lines.to_a.last.chomp
+      end
+
+      def failed_paths
+        return [] unless output
+        output.scan(/^== (.+) ==$/).flatten
+      end
+
+      class IO < ::IO
+        READ_CHUNK_SIZE = 10000
+
+        def read_available_nonblock
+          data = ''
+          loop do
+            begin
+              data << read_nonblock(READ_CHUNK_SIZE)
+            rescue ::IO::WaitReadable, EOFError
+              return data
+            end
+          end
+        end
+      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 = 0
+    PATCH = 1
+    VERSION = [MAJOR, MINOR, PATCH].join('.')
+  end
+end

data/spec/.rubocop.yml

@@ -0,0 +1,4 @@
+# Avoid warning "Possibly useless use of == in void context"
+# for `should ==`
+Syntax:
+  Enabled: false

data/spec/guard/rubocop/runner_spec.rb

@@ -0,0 +1,207 @@
+# coding: utf-8
+
+require 'spec_helper.rb'
+require 'term/ansicolor'
+
+describe Guard::Rubocop::Runner, :silence_output do
+  include CaptureHelper
+
+  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(:rubocop)
+    end
+
+    it 'executes rubocop' do
+      runner.should_receive(:rubocop)
+      runner.run
+    end
+
+    context 'when all files are passed' do
+      before do
+        runner.stub(:rubocop).and_return(0)
+      end
+      it { should be_true }
+    end
+
+    context 'when any file is failed' do
+      before do
+        runner.stub(:rubocop).and_return(1)
+      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(:rubocop).and_return(0)
+        end
+
+        if expectations[:passed]
+          include_examples 'notifies'
+        else
+          include_examples 'does not notify'
+        end
+      end
+
+      context 'when failed' do
+        before do
+          runner.stub(:rubocop).and_return(1)
+        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
+  end
+
+  describe '#rubocop' do
+    let(:paths) { ['spec/spec_helper.rb'] }
+
+    it 'runs rubocop command' do
+      capture(:stdout) do
+        runner.rubocop(paths)
+      end.should include 'inspected'
+    end
+
+    it 'returns exit code and output' do
+      exit_code, output = runner.rubocop(paths)
+      exit_code.should == 0
+      output.should include 'inspected'
+    end
+  end
+
+  describe '#output' do
+    subject { super().output }
+    let(:paths) { ['spec/spec_helper.rb'] }
+
+    context 'before running' do
+      it { should be_nil }
+    end
+
+    context 'after running' do
+      before do
+        runner.stub(:notify)
+      end
+
+      it 'returns uncolored output of rubocop command' do
+        captured_output = capture(:stdout) { runner.run(paths) }
+        runner.output.should == Term::ANSIColor.uncolor(captured_output)
+      end
+    end
+  end
+
+  shared_context 'stubbed output', stubbed_output: true do
+    before do
+      runner.stub(:output) do
+<<OUTPUT
+== /home/foo/guard-rubocop/lib/guard/rubocop.rb ==
+C:  1: Missing encoding comment.
+== /home/foo/guard-rubocop/spec/support/silence_output.rb ==
+C:  3: Ruby 1.8 hash syntax detected
+
+7 files inspected, 2 offences detected
+OUTPUT
+      end
+    end
+  end
+
+  describe '#notify', stubbed_output: true do
+    it 'notifies summary' do
+      Guard::Notifier.should_receive(:notify) do |message, options|
+        message.should == '7 files inspected, 2 offences detected'
+      end
+      runner.notify
+    end
+
+    it 'notifies with title "Rubocop results"' do
+      Guard::Notifier.should_receive(:notify) do |message, options|
+        options[:title].should == 'Rubocop results'
+      end
+      runner.notify
+    end
+
+    context 'when passed' do
+      before do
+        runner.stub(:passed).and_return(true)
+      end
+
+      it 'shows success image' do
+        Guard::Notifier.should_receive(:notify) do |message, options|
+          options[:image].should == :success
+        end
+        runner.notify
+      end
+    end
+
+    context 'when failed' do
+      before do
+        runner.stub(:passed).and_return(false)
+      end
+
+      it 'shows failed image' do
+        Guard::Notifier.should_receive(:notify) do |message, options|
+          options[:image].should == :failed
+        end
+        runner.notify
+      end
+    end
+  end
+
+  describe '#summary', stubbed_output: true do
+    subject { super().summary }
+
+    it 'returns summary line of output' do
+      should == '7 files inspected, 2 offences detected'
+    end
+  end
+
+  describe '#failed_paths', stubbed_output: true do
+    subject { super().failed_paths }
+
+    it 'returns failed file paths as array' do
+      should == [
+        '/home/foo/guard-rubocop/lib/guard/rubocop.rb',
+        '/home/foo/guard-rubocop/spec/support/silence_output.rb'
+      ]
+    end
+  end
+
+end

data/spec/guard/rubocop_spec.rb

@@ -0,0 +1,194 @@
+# coding: utf-8
+
+require 'spec_helper.rb'
+
+module Guard
+  describe Rubocop, :silence_output do
+    subject(:guard) { Rubocop.new(watchers, options) }
+    let(:watchers) { [] }
+    let(:options) { {} }
+
+    let(:runner) { 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 }
+      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
+    end
+
+    describe '#run_all', :processes_after_running do
+      subject { super().run_all }
+
+      before do
+        runner.stub(:run).and_return(true)
+      end
+
+      it 'inspects all files with rubocop' do
+        runner.should_receive(:run).with(no_args)
+        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)
+      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 to 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
+end

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+# coding: utf-8
+
+class NoExpectationExecutedError < StandardError
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+
+  # Original snippet by sorah
+  # https://gist.github.com/sorah/4315150
+  config.after do
+    result = self.example.metadata[:execution_result]
+
+    has_mock_expectations = !RSpec::Mocks.space.instance_eval do
+      receivers
+    end.empty?
+
+    next if result[:exception]
+    next if result[:pending_message]
+    next if RSpec::Matchers.last_should
+    next if has_mock_expectations
+
+    fail NoExpectationExecutedError
+  end
+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'
+  Coveralls.wear!
+elsif ENV['CI']
+  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/.rubocop.yml

@@ -0,0 +1,2 @@
+Syntax:
+  Enabled: false

data/spec/support/capture_helper.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+
+module CaptureHelper
+  def capture(stream_name)
+    stream_name = stream_name.to_s.downcase
+    original_stream = eval("$#{stream_name}")
+    eval("$#{stream_name} = StringIO.new")
+
+    begin
+      yield
+      result = eval("$#{stream_name}").string
+    ensure
+      eval("$#{stream_name} = original_stream")
+    end
+
+    result
+  end
+end

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,212 @@
+--- !ruby/object:Gem::Specification
+name: guard-rubocop
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yuji Nakayama
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: childprocess
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: term-ansicolor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.5.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.5.4
+- !ruby/object:Gem::Dependency
+  name: ruby_gntp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.3'
+description: Guard::Rubocop allows you to automatically check Ruby code style with
+  RuboCop when files are modified.
+email:
+- nkymyj@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- guard-rubocop.gemspec
+- lib/guard/.rubocop.yml
+- lib/guard/rubocop.rb
+- lib/guard/rubocop/runner.rb
+- lib/guard/rubocop/templates/Guardfile
+- lib/guard/rubocop/version.rb
+- spec/.rubocop.yml
+- spec/guard/rubocop/runner_spec.rb
+- spec/guard/rubocop_spec.rb
+- spec/spec_helper.rb
+- spec/support/.rubocop.yml
+- spec/support/capture_helper.rb
+- spec/support/silence_output.rb
+homepage: https://github.com/yujinakayama/guard-rubocop
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Guard plugin for RuboCop
+test_files:
+- spec/.rubocop.yml
+- spec/guard/rubocop/runner_spec.rb
+- spec/guard/rubocop_spec.rb
+- spec/spec_helper.rb
+- spec/support/.rubocop.yml
+- spec/support/capture_helper.rb
+- spec/support/silence_output.rb