guard-codeception 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0112040cdc13cc5a5c184fa9a7923ea8f42cd639
-  data.tar.gz: 84baffc58e9b884f57132c0ede6165bcaabcfb64
+  metadata.gz: 49dde6382fde6d091e3b9d5fa9101ff64c495e57
+  data.tar.gz: 4e8c0d537f330f77f5777d69a0b6dfd34c458c6c
 SHA512:
-  metadata.gz: f65d1eff3e67a9f770ee276c475f6ef8f7afbfb5d2a7ffeca3d6472a85637589fdb180af5f0f3727ec1e8e4b8b9ef60ef71c9b7fc1079a75b5dbb5522a015556
-  data.tar.gz: 266016584245b48433bcc05dcfc53619e437edcbfaa8dcfec20262ebbb4b89bf9045976b1739ee8f942784fa04c96695750e2773ff59d3305352a0a48b1e5c97
+  metadata.gz: 75dd1708f32b6df6e2d3b51f668b4d3687ff77cba31d00c8554c6a107453a034b45b9b96a9be678e11d6302f988c07f00a1551487ab63b57106078f5ca0030be
+  data.tar.gz: bba70fe25f8b722cb429c3a0e104c3634440ecc7be60eead568bbd4a6236306f6b7daf1e6ca004e816a9412b6768c769cf3deaffe263105b2f30f615831c44f4

data/.gitignore

@@ -16,3 +16,5 @@ test/tmp
 test/version_tmp
 tmp
 .DS_Store
+.idea
+spec/fixtures/codeception/vendor

data/Gemfile

@@ -2,3 +2,6 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in guard-codeception.gemspec
 gemspec
+
+gem 'coveralls', require: false
+gem 'simplecov', require: false, group: :test

data/README.md

@@ -1,6 +1,3 @@
-# TODO:
-- 100% code coverage
-
 # Guard::Codeception [![Build Status](https://travis-ci.org/colby-swandale/guard-codeception.png?branch=master)](https://travis-ci.org/colby-swandale/guard-codeception)
 
 Guard::Codeception is an extension to the [guard gem](http://guardgem.org/) for the [codeception](http://codeception.com/) testing framework 
@@ -70,3 +67,7 @@ $ guard
 
 [Colby Swandale](https://github.com/colby-swandale)
 
+## Contributors
+
+[tmuntan1](https://github.com/tmuntan1)
+

data/guard-codeception.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'guard', '>= 1.1.0'
+  spec.add_dependency 'guard', '~> 2.0'
  
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rake'

data/lib/guard/codeception/notifier.rb

@@ -0,0 +1,31 @@
+module Guard
+  class Codeception
+    class Notifier
+
+      TITLE = 'Codeception Results'
+
+      def notify(results)
+        image     = _image(results)
+        message   = _message(results)
+        ::Guard::Notifier::notify(message, {title: TITLE, image: image})
+      end
+
+      private
+
+      def _image(results)
+        return :failed if results[:failures] > 0
+        return :failed if results[:errors] > 0
+        :success
+      end
+
+      def _message(results)
+        message = "#{results[:tests]} tests\n"
+        message << "#{results[:assertions]} assertions\n"
+        message << "#{results[:failures]} failures\n"
+        message << "#{results[:errors]} errors\n"
+        message
+      end
+
+    end
+  end
+end

data/lib/guard/codeception/options.rb

@@ -0,0 +1,22 @@
+module Guard
+  class Codeception
+    module Options
+
+      DEFAULTS = {
+          test_on_start:  false,
+          suites:         [:acceptance, :functional, :unit],
+          debug:          false,
+          groups:         [],
+          codecept:       'codecept',
+          cli:            false
+      }
+
+      class << self
+        def with_defaults(options={})
+          DEFAULTS.merge(options)
+        end
+      end
+
+    end
+  end
+end

data/lib/guard/codeception/parser.rb

@@ -0,0 +1,22 @@
+module Guard
+  class Codeception
+    class Parser
+
+      def parse(text)
+        {
+            tests:      _get(text, 'Tests'),
+            failures:   _get(text, 'Failures'),
+            assertions: _get(text, 'Assertions'),
+            errors:     _get(text, 'Errors')
+        }
+      end
+
+      private
+
+      def _get (text, find)
+        text.to_s.match(%r{#{find.to_s}: \d+}).to_s.split(': ')[1].to_i
+      end
+
+    end
+  end
+end

data/lib/guard/codeception/runner.rb

@@ -1,44 +1,59 @@
 module Guard
   class Codeception
+    class Runner
 
-    module Runner
-
-			class << self
-
-				def run(options = {})
-					UI.info 'Starting Tests'
-
-					if !codeception_exists? options[:codecept]
-						UI.error 'codecept isnt\'t avaliable, have you installed codeception?'
-						return false
-					end
-
-					cmd = []
-					cmd << options[:codecept]
-					cmd << 'run'
-					cmd << options[:suites].join(',')
-					cmd << '-g ' + options[:groups].join(' -g ') if !options[:groups].empty?
-					cmd << '--debug' if options[:debug]
-					cmd << options[:cli] if options[:cli]
-					
-					UI.info execute make(cmd)
-				end
-				
-				def codeception_exists?(codecept_path)
-					%x(#{codecept_path} --version)
-						true
-					rescue Errno::ENOENT
-						false
-				end
-
-				def make(cmd_parts)
-					cmd_parts.join ' '
-				end
-
-				def execute(cmd)
-					return %x(#{cmd})
-				end
-			end
-		end
-	end
-end	
+      require 'guard/codeception/parser'
+      require 'guard/codeception/notifier'
+
+      attr_accessor :options, :parser, :notifier
+
+      CODECEPTION_FAILURES_EXIT_CODE  = 1
+      CODECEPTION_ERRORS_EXIT_CODE    = 2
+
+      def initialize(options = {})
+        @options  = options
+        @parser   = Guard::Codeception::Parser.new
+        @notifier = Guard::Codeception::Notifier.new
+      end
+
+      def run
+        _run if _codeception_exists?
+      end
+
+      private
+
+      def _run
+        UI.info 'Codeception: Starting Tests. Results will be displayed when finished testing.'
+        output = _execute_command _codeception_command
+        notifier.notify(parser.parse(output)) if $?.success?
+        output
+      end
+
+      def _codeception_exists?
+        %x(#{options[:codecept]} --version)
+        true
+      rescue Errno::ENOENT
+        UI.error "codecept isn't available at #{options[:codecept]}, have you installed codeception?"
+        false
+      end
+
+      def _codeception_command
+        cmd = []
+
+        cmd << options[:codecept]
+        cmd << 'run'
+        cmd << options[:suites].join(',')
+        cmd << '-g ' + options[:groups].join(' -g ') unless options[:groups].empty?
+        cmd << '--debug' if options[:debug]
+        cmd << options[:cli] if options[:cli]
+
+        cmd.join ' '
+      end
+
+      def _execute_command(command)
+        %x{#{command}}
+      end
+
+    end
+  end
+end

data/lib/guard/codeception/templates/Guardfile

@@ -1,3 +1,3 @@
-guard 'codeception' do
-    watch(%r{^.*\.php$})
+guard :codeception do
+  watch(%r{^.*\.php$})
 end

data/lib/guard/codeception/version.rb

@@ -1,5 +1,5 @@
 module Guard
   module CodeceptionVersion
-    VERSION = "1.1.0"
+    VERSION = '1.2.0'
   end
 end

data/lib/guard/codeception.rb

@@ -2,34 +2,44 @@ require 'guard'
 require 'guard/plugin'
 
 module Guard
-	class Codeception < Plugin
-		
-		autoload :Runner, 'guard/codeception/runner'
-
-		DEFAULT_OPTIONS = {
-			:test_on_start 	=> false,
-			:suites			=> [:acceptance, :functional, :unit],
-			:debug 			=> false,
-			:groups 		=> [],
-			:codecept 		=> 'codecept',
-			:cli			=> false
-		}
-
-		def initialize(options = {})
-			@options = DEFAULT_OPTIONS.merge(options)
-			super(@options)
-		end
-		
-		def start
-			run if options[:test_on_start]
-		end
-		
-		def run_on_change(paths)
-			 run
-		end
-	
-		def run
-			Runner.run options
-		end
-	end
+  class Codeception < Plugin
+
+    require 'guard/codeception/runner'
+    require 'guard/codeception/options'
+
+    attr_accessor :runner, :options
+
+    def initialize(options = {})
+      super
+      @options  = Options.with_defaults(options)
+      @runner   = Runner.new(@options)
+    end
+
+    def start
+      _show_start_message
+      puts runner.run if _should_test_on_start?
+    end
+
+    def run_on_modifications(paths)
+      puts runner.run
+    end
+
+    def reload
+    end
+
+    def run_all
+      puts runner.run
+    end
+
+    private
+
+    def _show_start_message
+      ::Guard::UI::info 'Guard::Codeception is running'
+    end
+
+    def _should_test_on_start?
+      options[:test_on_start]
+    end
+
+  end
 end

data/spec/fixtures/codeception/.gitignore

@@ -0,0 +1 @@
+vendor

data/spec/guard/codeception/notifier_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Guard::Codeception::Notifier do
+
+  let (:results) {
+    {
+      tests: 100,
+      assertions: 1000,
+      errors: 0,
+      failures: 0
+    }
+  }
+
+  describe '#notify' do
+
+    it 'should give proper message' do
+      message = "100 tests\n"
+      message << "1000 assertions\n"
+      message << "0 failures\n"
+      message << "0 errors\n"
+
+      ::Guard::Notifier::should_receive(:notify).with(message, {image: :success, title: Guard::Codeception::Notifier::TITLE})
+      subject.notify(results)
+    end
+
+    it 'should give success message' do
+      ::Guard::Notifier::should_receive(:notify).with(message(results), {image: :success, title: Guard::Codeception::Notifier::TITLE})
+      subject.notify(results)
+    end
+
+    it 'should give failed message' do
+      @results = results.merge(failures: 1)
+      ::Guard::Notifier::should_receive(:notify).with(message(@results), {image: :failed, title: Guard::Codeception::Notifier::TITLE})
+      subject.notify(@results)
+    end
+
+    it 'should give error message' do
+      @results = results.merge(errors: 1)
+      ::Guard::Notifier::should_receive(:notify).with(message(@results), {image: :failed, title: Guard::Codeception::Notifier::TITLE})
+      subject.notify(@results)
+    end
+
+  end
+
+  # taken from the class to make testing easier
+  def message(results)
+    message = "#{results[:tests]} tests\n"
+    message << "#{results[:assertions]} assertions\n"
+    message << "#{results[:failures]} failures\n"
+    message << "#{results[:errors]} errors\n"
+    message
+  end
+
+end

data/spec/guard/codeception/options_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Guard::Codeception::Options do
+
+  describe '#with_defaults' do
+    it 'should have defaults if no overrides are provided' do
+      defaults = subject.with_defaults({})
+      defaults.should eq(Guard::Codeception::Options::DEFAULTS)
+    end
+    it 'should override defaults with provided options' do
+      expected  = Guard::Codeception::Options::DEFAULTS.merge({test_on_start: true})
+      defaults  = subject.with_defaults({test_on_start: true})
+      defaults.should eq(expected)
+    end
+  end
+
+end

data/spec/guard/codeception/parser_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Guard::Codeception::Parser do
+
+  describe '#parse' do
+    it 'should give 0 if nothing exists in the tests' do
+      results = subject.parse('')
+      results.each do |key, value|
+        value.should eq(0)
+      end
+    end
+
+    it 'should give values if they exists' do
+      keys = [:tests, :assertions, :failures, :errors]
+
+      keys.each do |key|
+        results = subject.parse("foo #{key.to_s.capitalize}: 42 bar")
+        results[key].should eq(42)
+      end
+
+    end
+  end
+
+end

data/spec/guard/codeception/runner_spec.rb

@@ -2,58 +2,97 @@ require 'spec_helper'
 
 describe Guard::Codeception::Runner do
 
-	let (:default_options) {{
-		:test_on_start 	=> false,
-		:suites			=> [:acceptance],
-		:groups			=> [:group1],
-		:debug 			=> false,
-		:codecept 		=> Dir.getwd + '/spec/fixtures/codeception/vendor/bin/codecept',
-		:cli			=> '-c ' + Dir.getwd + '/spec/fixtures/codeception/codeception.yml'
-	}}
-
-	describe '#run' do
-
-		# TODO: test #make
-
-		it 'calls #execute' do
-			subject.should_receive(:execute).with(default_options[:codecept] + ' run acceptance -g group1 -c ' + Dir.getwd + '/spec/fixtures/codeception/codeception.yml')
-			subject.run default_options
-		end
-
-		it 'calls #codeception_exists?' do
-			subject.should_receive(:codeception_exists?)
-			subject.run default_options
-		end
-	end
-
-	describe '#codeception_exists?' do
-
-		context 'when codecept not found' do
-
-			it 'returns false' do
-				expect(subject.codeception_exists?('notcodecept')).to be_false
-			end	
-		end
-
-		it 'returns true' do
-			expect(subject.codeception_exists?(default_options[:codecept])).to be_true
-		end
-	end
-
-	describe '#make' do
-
-		it 'returns the command for #system to execute' do
-			cmd = subject.make ['codecept', 'run', 'foo,bar']
-			expect(cmd).to eq('codecept run foo,bar')
-		end
-	end
-
-	describe '#execute' do
-
-		it 'returns the output from codeception' do
-			output = subject.execute default_options[:codecept] + ' run foo,bar'
-			output.should_not be_empty
-			output.should include 'Codeception PHP Testing Framework'
-		end
-	end
+  let (:runner) { Guard::Codeception::Runner.new(
+      {
+          test_on_start:  false,
+          suites:         [:acceptance],
+          groups:         [:group1],
+          debug:          false,
+          codecept:       Dir.getwd + '/spec/fixtures/codeception/vendor/bin/codecept',
+          cli:            '-c ' + Dir.getwd + '/spec/fixtures/codeception/codeception.yml'
+      }
+  ) }
+
+  describe '#run' do
+
+    it 'calls #codeception_exists?' do
+      runner.should_receive(:_codeception_exists?)
+      runner.run
+    end
+
+    it 'displays error when codeception does not exist' do
+      runner = Guard::Codeception::Runner.new({codecept: 'foo'})
+      ::Guard::UI.should_receive(:error)
+      runner.run
+    end
+
+    it 'calls system commands' do
+      runner.should_receive(:`).twice # codeception check, command
+      ::Guard::UI.should_receive(:info)
+      runner.run
+    end
+
+  end
+
+  describe '#_codeception_command' do
+
+    describe 'suites' do
+      it 'should create a proper system command with multiple suites' do
+        test_runner = Guard::Codeception::Runner.new(runner.options.merge({suites: [:unit, :acceptance]}))
+        test_runner.should_receive(:_execute_command).with("#{runner.options[:codecept]} run unit,acceptance -g group1 #{runner.options[:cli]}")
+        ::Guard::UI.should_receive(:info)
+        test_runner.run
+      end
+    end
+
+    describe 'groups' do
+      it 'should create a proper system command with multiple groups' do
+        test_runner = Guard::Codeception::Runner.new(runner.options.merge({groups: [:group1, :group2]}))
+        test_runner.should_receive(:_execute_command).with("#{runner.options[:codecept]} run acceptance -g group1 -g group2 #{runner.options[:cli]}")
+        ::Guard::UI.should_receive(:info)
+        test_runner.run
+      end
+
+      it 'should create a proper system command with no groups' do
+        test_runner = Guard::Codeception::Runner.new(runner.options.merge({groups: []}))
+        test_runner.should_receive(:_execute_command).with("#{runner.options[:codecept]} run acceptance #{runner.options[:cli]}")
+        ::Guard::UI.should_receive(:info)
+        test_runner.run
+      end
+    end
+
+    describe 'debug' do
+      it 'should add debug when needed' do
+        test_runner = Guard::Codeception::Runner.new(runner.options.merge({debug: true}))
+        test_runner.should_receive(:_execute_command).with("#{runner.options[:codecept]} run acceptance -g group1 --debug #{runner.options[:cli]}")
+        ::Guard::UI.should_receive(:info)
+        test_runner.run
+      end
+
+      it 'should not add debug when needed' do
+        test_runner = Guard::Codeception::Runner.new(runner.options.merge({debug: false}))
+        test_runner.should_receive(:_execute_command).with("#{runner.options[:codecept]} run acceptance -g group1 #{runner.options[:cli]}")
+        ::Guard::UI.should_receive(:info)
+        test_runner.run
+      end
+    end
+
+    describe 'cli' do
+      it 'should add cli option when supplied' do
+        test_runner = Guard::Codeception::Runner.new(runner.options.merge({cli: '-c foo'}))
+        test_runner.should_receive(:_execute_command).with("#{runner.options[:codecept]} run acceptance -g group1 -c foo")
+        ::Guard::UI.should_receive(:info)
+        test_runner.run
+      end
+
+      it 'should not add cli option when supplied' do
+        test_runner = Guard::Codeception::Runner.new(runner.options.merge({cli: nil}))
+        test_runner.should_receive(:_execute_command).with("#{runner.options[:codecept]} run acceptance -g group1")
+        ::Guard::UI.should_receive(:info)
+        test_runner.run
+      end
+    end
+
+  end
+
 end

data/spec/guard/codeception_spec.rb

@@ -2,86 +2,107 @@ require 'spec_helper'
 
 describe Guard::Codeception do
 
-	let (:runner) { Guard::Codeception::Runner }
+  let (:runner) { Guard::Codeception::Runner }
 
-	describe '#initialize' do
+  describe '#initialize' do
 
-		context 'when no options are provided' do
+    context 'when no options are provided' do
 
-			it 'has :test_on_start set to false' do
-				expect(subject.options[:test_on_start]).to be_false
-			end
+      it 'has :test_on_start set to false' do
+        expect(subject.options[:test_on_start]).to be_false
+      end
 
-			it 'has :suites set to [:acceptance, :functional, :unit]' do
-				expect(subject.options[:suites]).to match_array([:acceptance, :functional, :unit])
-			end
+      it 'has :suites set to [:acceptance, :functional, :unit]' do
+        expect(subject.options[:suites]).to match_array([:acceptance, :functional, :unit])
+      end
 
-			it 'has :debug set to false' do
-				expect(subject.options[:debug]).to be_false
-			end
+      it 'has :debug set to false' do
+        expect(subject.options[:debug]).to be_false
+      end
 
-			it 'has :groups set to []' do
-				expect(subject.options[:groups]).to match_array([])
-			end
-		end
+      it 'has :groups set to []' do
+        expect(subject.options[:groups]).to match_array([])
+      end
+    end
 
-		context 'when options are provided' do
+    context 'when options are provided' do
 
-			subject do
-				Guard::Codeception.new test_on_start: true, suites: [:foo], debug: true, groups: [:bar] 
-			end
+      subject do
+        Guard::Codeception.new test_on_start: true, suites: [:foo], debug: true, groups: [:bar]
+      end
 
-			it 'has :test_on_start set to true' do
-				expect(subject.options[:test_on_start]).to be_true
-			end
+      it 'has :test_on_start set to true' do
+        expect(subject.options[:test_on_start]).to be_true
+      end
 
-			it 'has suites set to []' do
-				expect(subject.options[:suites]).to match_array([:foo])
-			end	
+      it 'has suites set to []' do
+        expect(subject.options[:suites]).to match_array([:foo])
+      end
 
-			it 'has debug set to true' do
-				expect(subject.options[:debug]).to be_true
-			end
+      it 'has debug set to true' do
+        expect(subject.options[:debug]).to be_true
+      end
 
-			it 'has groups set to [:foo]' do
-				expect(subject.options[:groups]).to match_array([:bar])
-			end
-		end
-	end
+      it 'has groups set to [:foo]' do
+        expect(subject.options[:groups]).to match_array([:bar])
+      end
+    end
+  end
 
-	describe '#start' do
+  describe '#start' do
 
-		it 'should\'t call #run' do
-			subject.should_not_receive :run
-			subject.start
-		end
+    context 'with :run_on_start set to false' do
 
-		context 'with :run_on_start set to true' do
+      subject do
+        Guard::Codeception.new test_on_start: false
+      end
 
-			subject do
-				Guard::Codeception.new test_on_start: true
-			end
+      it 'should\'t call #run' do
+        subject.should_not_receive :run
+        ::Guard::UI.should_receive(:info)
+        subject.start
+      end
+    end
 
-			it 'should call #run' do
-				subject.should_receive :run
-				subject.start
-			end
-		end
-	end
+    context 'with :run_on_start set to true' do
 
-	describe '#runs_on_change' do
+      subject do
+        Guard::Codeception.new test_on_start: true
+      end
 
-		it 'should call #run' do
-			subject.should_receive :run
-			subject.run_on_change []
-		end
-	end
+      it 'should call #run' do
+        subject.runner.should_receive :run
+        ::Guard::UI.should_receive(:info)
+        subject.start
+      end
 
-	describe '#run' do
+    end
+  end
+
+  describe '#run_all' do
+
+    subject do
+      Guard::Codeception.new
+    end
+
+    it 'should call #run_all' do
+      subject.runner.should_receive :run
+      subject.run_all
+    end
+
+  end
+
+  describe '#run_on_modification' do
+
+    subject do
+      Guard::Codeception.new
+    end
+
+    it 'should call #run_all' do
+      subject.runner.should_receive :run
+      subject.run_on_modifications []
+    end
+
+  end
 
-		it 'should call Runner#run' do
-			runner.should_receive :run
-			subject.run
-		end
-	end
 end

data/spec/spec_helper.rb

@@ -1,9 +1,21 @@
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter '/spec/'
+  add_group 'Codeception', 'lib/guard'
+end
+
 require 'rspec'
 require 'guard/codeception'
 
+#require 'coveralls'
+
+
+
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
-  config.run_all_when_everything_filtered = true
+  config.run_all_when_everything_filtered                = true
+  config.order                                           = :random
+
   config.filter_run :focus
-  config.order = 'random'
 end

metadata

@@ -1,69 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: guard-codeception
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Colby Swandale
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-22 00:00:00.000000000 Z
+date: 2014-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: '2.0'
 - !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: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '2.14'
 description: Guard gem for codeception
@@ -73,18 +73,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- ".travis.yml"
+- .gitignore
+- .rspec
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - guard-codeception.gemspec
 - lib/guard/codeception.rb
+- lib/guard/codeception/notifier.rb
+- lib/guard/codeception/options.rb
+- lib/guard/codeception/parser.rb
 - lib/guard/codeception/runner.rb
 - lib/guard/codeception/templates/Guardfile
 - lib/guard/codeception/version.rb
+- spec/fixtures/codeception/.gitignore
 - spec/fixtures/codeception/codeception.yml
 - spec/fixtures/codeception/composer.json
 - spec/fixtures/codeception/composer.lock
@@ -108,6 +112,9 @@ files:
 - spec/fixtures/codeception/tests/unit/_bootstrap.php
 - spec/fixtures/results/codeception_failure
 - spec/fixtures/results/codeception_success
+- spec/guard/codeception/notifier_spec.rb
+- spec/guard/codeception/options_spec.rb
+- spec/guard/codeception/parser_spec.rb
 - spec/guard/codeception/runner_spec.rb
 - spec/guard/codeception_spec.rb
 - spec/spec_helper.rb
@@ -121,21 +128,22 @@ 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.2.1
+rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
 summary: guard-codeception automatically runs codeception on file changes
 test_files:
+- spec/fixtures/codeception/.gitignore
 - spec/fixtures/codeception/codeception.yml
 - spec/fixtures/codeception/composer.json
 - spec/fixtures/codeception/composer.lock
@@ -159,6 +167,10 @@ test_files:
 - spec/fixtures/codeception/tests/unit/_bootstrap.php
 - spec/fixtures/results/codeception_failure
 - spec/fixtures/results/codeception_success
+- spec/guard/codeception/notifier_spec.rb
+- spec/guard/codeception/options_spec.rb
+- spec/guard/codeception/parser_spec.rb
 - spec/guard/codeception/runner_spec.rb
 - spec/guard/codeception_spec.rb
 - spec/spec_helper.rb
+has_rdoc: