guard-fast_spec 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010-2012 Thibaud Guillaume-Gentil
+
+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,194 @@
+# Guard::RSpec [![Build Status](https://secure.travis-ci.org/guard/guard-rspec.png?branch=master)](http://travis-ci.org/guard/guard-rspec)
+
+RSpec guard allows to automatically & intelligently launch specs when files are modified.
+
+* Compatible with RSpec 1.x & RSpec 2.x (>= 2.4 needed for the notification feature).
+* Tested against Ruby 1.8.7, 1.9.2, 1.9.3, REE and the latest versions of JRuby & Rubinius.
+
+## Install
+
+Please be sure to have [Guard](https://github.com/guard/guard) installed before continue.
+
+Install the gem:
+
+```
+$ gem install guard-rspec
+```
+
+Add it to your Gemfile (inside development group):
+
+``` ruby
+group :development do
+  gem 'guard-rspec'
+end
+```
+
+Add guard definition to your Guardfile by running this command:
+
+```
+$ guard init rspec
+```
+
+## Usage
+
+Please read [Guard usage doc](https://github.com/guard/guard#readme)
+
+## Guardfile
+
+RSpec guard can be really adapted to all kind of projects.
+
+### Standard RubyGem project
+
+``` ruby
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+```
+
+### Typical Rails app
+
+``` ruby
+guard 'rspec' do
+  watch('spec/spec_helper.rb')                        { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^lib/(.+)\.rb$})                           { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+end
+```
+
+Please read [Guard doc](https://github.com/guard/guard#readme) for more information about the Guardfile DSL.
+
+## Options
+
+By default, Guard::RSpec automatically detect your RSpec version (with the `spec_helper.rb` syntax or with Bundler) but you can force the version with the `:version` option:
+
+``` ruby
+guard 'rspec', :version => 2 do
+  # ...
+end
+```
+
+You can pass any of the standard RSpec CLI options using the `:cli` option:
+
+``` ruby
+guard 'rspec', :cli => "--color --format nested --fail-fast --drb" do
+  # ...
+end
+```
+
+By default, Guard::RSpec will only look for spec files within `spec` in your project root. You can configure Guard::RSpec to look in additional paths by using the `:spec_paths` option:
+
+``` ruby
+guard 'rspec', :spec_paths => ["spec", "vendor/engines/reset/spec"] do
+  # ...
+end
+```
+If you have only one path to look, you can configure `:spec_paths` option with a string:
+
+``` ruby
+guard 'rspec', :spec_paths => "test" do
+  # ...
+end
+```
+
+
+Former `:color`, `:drb`, `:fail_fast` and `:formatter` options are deprecated and have no effect anymore.
+
+### List of available options:
+
+``` ruby
+:version => 1                # force use RSpec version 1, default: 2
+:cli => "-c -f doc"          # pass arbitrary RSpec CLI arguments, default: "-f progress"
+:bundler => false            # don't use "bundle exec" to run the RSpec command, default: true
+:binstubs => true            # use "bin/rspec" to run the RSpec command (implies :bundler => true), default: false
+:rvm => ['1.8.7', '1.9.2']   # directly run your specs on multiple Rubies, default: nil
+:notification => false       # display Growl (or Libnotify) notification after the specs are done running, default: true
+:all_after_pass => false     # run all specs after changed specs pass, default: true
+:all_on_start => false       # run all the specs at startup, default: true
+:keep_failed => false        # keep failed specs until they pass, default: true
+:run_all => { :cli => "-p" } # cli arguments to use when running all specs, default: same as :cli
+:spec_paths => ["spec"]      # specify an array of paths that contain spec files
+```
+
+### DRb mode
+
+When you specify `--drb` within `:cli`, guard-rspec will circumvent the `rspec` command line tool by
+directly communicating with the RSpec DRb server.  This avoids the extra overhead incurred by your
+shell, bundler and loading RSpec's environment just to send a DRb message.  It shaves off a
+second or two before the specs start to run; they should run almost immediately.
+
+
+Notification
+------------
+
+The notification feature is only available for RSpec < 2, and RSpec >= 2.4 (due to the multiple-formatters feature that was present in RSpec 1, was removed in RSpec 2 and reintroduced in RSpec 2.4). So if you are using a version between 2 and 2.4, you should disable the notification with <tt>:notification => false</tt>. Otherwise, nothing will be displayed in the terminal when your specs will run.
+
+The best solution is still to update RSpec to the latest version!
+
+Formatters
+----------
+
+The `:formatter` option has been removed since CLI arguments can be passed through the `:cli` option. If you want to use the former Instafail formatter, you need to use [rspec-instafail](http://rubygems.org/gems/rspec-instafail) gem instead:
+
+``` ruby
+# in your Gemfile
+gem 'rspec-instafail'
+
+# in your Guardfile
+guard 'rspec', :cli => '-r rspec/instafail -f RSpec::Instafail' do
+  # ...
+end
+```
+
+Default formatter is the `progress` formatter (same as RSpec default).
+
+Running a subset of all specs
+-----------
+
+The `:all_on_start` and `:all_after_pass` options cause all specs located in the `spec` directory to be run.  If there
+are some specs you want to skip, you can tag them with RSpec metadata (such as `:slow => true`)
+and skip them with the cli `--tag` option (i.e. `--tag ~slow`).
+
+You can also use option :spec_paths to override paths used when running all specs.
+You can use this feature to create multiple groups of guarded specs with distinct paths, and execute each in own process:
+
+``` ruby
+# in your Guardfile
+group 'acceptance-tests' do
+  guard 'rspec', :spec_paths => ['spec/acceptance'] do
+    # ...
+  end
+end
+
+group 'unit-tests' do
+  guard 'rspec', :spec_paths => ['spec/models', 'spec/controllers', 'spec/routing'] do
+    # ...
+  end
+end
+```
+
+
+Development
+-----------
+
+* Source hosted at [GitHub](https://github.com/guard/guard-rspec)
+* Report issues/Questions/Feature requests on [GitHub Issues](https://github.com/guard/guard-rspec/issues)
+
+Pull requests are very welcome! Make sure your patches are well tested. Please create a topic branch for every separate change
+you make.
+
+Testing
+-------
+
+Please run `rake spec:prepare_fixtures` once before launching specs.
+
+Author
+------
+
+[Thibaud Guillaume-Gentil](https://github.com/thibaudgg)

data/lib/guard/fast_spec/formatter.rb

@@ -0,0 +1,49 @@
+require "#{File.dirname(__FILE__)}/../fast_spec"
+require 'guard/notifier'
+
+module Guard::FastSpec::Formatter
+
+  def guard_message(example_count, failure_count, pending_count, duration)
+    message = "#{example_count} examples, #{failure_count} failures"
+    if pending_count > 0
+      message << " (#{pending_count} pending)"
+    end
+    message << "\nin #{round_float(duration)} seconds"
+    message
+  end
+
+  # failed | pending | success
+  def guard_image(failure_count, pending_count)
+    if failure_count > 0
+      :failed
+    elsif pending_count > 0
+      :pending
+    else
+      :success
+    end
+  end
+
+  def priority(image)
+    { :failed => 2,
+      :pending => -1,
+      :success => -2
+    }[image]
+  end
+
+  def notify(message, image)
+    Guard::Notifier.notify(message, :title => "FastSpec results", :image => image,
+      :priority => priority(image))
+  end
+
+private
+
+  def round_float(float, decimals = 4)
+    if Float.instance_method(:round).arity == 0 # Ruby 1.8
+      factor = 10**decimals
+      (float*factor).round / factor.to_f
+    else # Ruby 1.9
+      float.round(decimals)
+    end
+  end
+
+end

data/lib/guard/fast_spec/formatters/notification_rspec.rb

@@ -0,0 +1,13 @@
+require "#{File.dirname(__FILE__)}/../formatter"
+require "rspec/core/formatters/base_formatter"
+
+class Guard::FastSpec::Formatter::NotificationRSpec < RSpec::Core::Formatters::BaseFormatter
+  include Guard::FastSpec::Formatter
+
+  def dump_summary(duration, total, failures, pending)
+    message = guard_message(total, failures, pending, duration)
+    image   = guard_image(failures, pending)
+    notify(message, image)
+  end
+
+end

data/lib/guard/fast_spec/formatters/notification_spec.rb

@@ -0,0 +1,13 @@
+require "#{File.dirname(__FILE__)}/../formatter"
+require "spec/runner/formatter/base_formatter"
+
+class Guard::FastSpec::Formatter::NotificationSpec < Spec::Runner::Formatter::BaseFormatter
+  include Guard::FastSpec::Formatter
+
+  def dump_summary(duration, total, failures, pending)
+    message = guard_message(total, failures, pending, duration)
+    image   = guard_image(failures, pending)
+    notify(message, image)
+  end
+
+end

data/lib/guard/fast_spec/inspector.rb

@@ -0,0 +1,72 @@
+module Guard
+  class FastSpec
+    class Inspector
+
+      def initialize(options = {})
+        self.excluded   = options[:exclude]
+        self.spec_paths = options[:spec_paths]
+      end
+
+      def excluded
+        @excluded || []
+      end
+
+      def excluded=(pattern)
+        @excluded = Dir[pattern.to_s]
+      end
+
+      def spec_paths
+        @spec_paths || []
+      end
+
+      def spec_paths=(paths)
+        @spec_paths = Array(paths)
+      end
+
+      def clean(paths)
+        paths.uniq!
+        paths.compact!
+        clear_spec_files_list_after do
+          paths = paths.select { |path| should_run_spec_file?(path) }
+        end
+        paths.reject { |p| included_in_other_path?(p, paths) }
+      end
+
+    private
+
+      def should_run_spec_file?(path)
+        (spec_file?(path) || feature_file?(path) || spec_folder?(path)) && !excluded.include?(path)
+      end
+
+      def spec_file?(path)
+        spec_files.include?(path)
+      end
+
+      def feature_file?(path)
+        feature_files.include?(path)
+      end
+
+      def spec_folder?(path)
+        path.match(%r{^(#{spec_paths.join("|")})[^\.]*$})
+      end
+
+      def spec_files
+        @spec_files ||= spec_paths.collect { |path| Dir[File.join(path, "**{,/*/**}", "*_spec.rb")] }.flatten
+      end
+
+      def feature_files
+        @feature_files ||= spec_paths.collect { |path| Dir[File.join(path, "**{,/*/**}", "*.feature")] }.flatten
+      end
+
+      def clear_spec_files_list_after
+        yield
+        @spec_files = nil
+      end
+
+      def included_in_other_path?(path, paths)
+        (paths - [path]).any? { |p| path.include?(p) && path.sub(p, '').include?('/') }
+      end
+
+    end
+  end
+end

data/lib/guard/fast_spec/runner.rb

@@ -0,0 +1,204 @@
+module Guard
+  class FastSpec
+    class Runner
+      attr_reader :fast_spec_version
+
+      FAILURE_EXIT_CODE = 2
+
+      def initialize(options = {})
+        @options = {
+          :bundler      => true,
+          :binstubs     => false,
+          :rvm          => nil,
+          :cli          => nil,
+          :notification => true
+        }.merge(options)
+
+        deprecations_warnings
+      end
+
+      def run(paths, options = {})
+        return false if paths.empty?
+
+        message = options[:message] || "Running: #{paths.join(' ')}"
+        UI.info(message, :reset => true)
+
+        options = @options.merge(options)
+
+        if drb_used?
+          run_via_drb(paths, options)
+        else
+          run_via_shell(paths, options)
+        end
+      end
+
+      def fast_spec_version
+        @fast_spec_version ||= @options[:version] || determine_fast_spec_version
+      end
+
+      def fast_spec_executable
+        @fast_spec_executable ||= begin
+          exec = fast_spec_class.downcase
+          binstubs? ? "bin/#{exec}" : exec
+        end
+      end
+
+      def failure_exit_code_supported?
+        @failure_exit_code_supported ||= begin
+          cmd_parts = []
+          cmd_parts << "bundle exec" if bundler?
+          cmd_parts << fast_spec_executable
+          cmd_parts << "--help"
+          `#{cmd_parts.join(' ')}`.include? "--failure-exit-code"
+        end
+      end
+
+      def fast_spec_class
+        @fast_spec_class ||= case fast_spec_version
+                         when 1
+                           "Spec"
+                         when 2
+                           "RSpec"
+                         end
+      end
+
+    private
+
+      def fast_spec_arguments(paths, options)
+        arg_parts = []
+        arg_parts << options[:cli]
+        arg_parts << "-f progress" if !options[:cli] || options[:cli].split(/[\s=]/).none? { |w| %w[-f --format].include?(w) }
+        if @options[:notification]
+          arg_parts << "-r #{File.dirname(__FILE__)}/formatters/notification_#{fast_spec_class.downcase}.rb"
+          arg_parts << "-f Guard::FastSpec::Formatter::Notification#{fast_spec_class}#{fast_spec_version == 1 ? ":" : " --out "}/dev/null"
+        end
+        arg_parts << "--failure-exit-code #{FAILURE_EXIT_CODE}" if failure_exit_code_supported?
+        arg_parts << paths.join(' ')
+
+        arg_parts.compact.join(' ')
+      end
+
+      def fast_spec_command(paths, options)
+        cmd_parts = []
+        cmd_parts << "rvm #{@options[:rvm].join(',')} exec" if @options[:rvm].respond_to?(:join)
+        cmd_parts << "bundle exec" if bundler?
+        cmd_parts << fast_spec_executable
+        cmd_parts << fast_spec_arguments(paths, options)
+
+        cmd_parts.compact.join(' ')
+      end
+
+      def run_via_shell(paths, options)
+        success = system(fast_spec_command(paths, options))
+
+        if @options[:notification] && !drb_used? && !success && fast_spec_command_exited_with_an_exception?
+          Notifier.notify("Failed", :title => "FastSpec results", :image => :failed, :priority => 2)
+        end
+
+        success
+      end
+
+      def fast_spec_command_exited_with_an_exception?
+        failure_exit_code_supported? && $?.exitstatus != FAILURE_EXIT_CODE
+      end
+
+      # We can optimize this path by hitting up the drb server directly, circumventing the overhead
+      # of the user's shell, bundler and ruby environment.
+      def run_via_drb(paths, options)
+        require "shellwords"
+        argv = fast_spec_arguments(paths, options).shellsplit
+
+        # The user can specify --drb-port for fast_spec, we need to honor it.
+        if idx = argv.index("--drb-port")
+          port = argv[idx + 1].to_i
+        end
+        port = ENV["RSPEC_DRB"] || 8989 unless port && port > 0
+
+        ret = drb_service(port.to_i).run(argv, $stderr, $stdout)
+        ret == 0
+      rescue DRb::DRbConnError
+        # Fall back to the shell runner; we don't want to mangle the environment!
+        run_via_shell(paths, options)
+      end
+
+      def drb_used?
+        if @drb_used.nil?
+          @drb_used = @options[:cli] && @options[:cli].include?('--drb')
+        else
+          @drb_used
+        end
+      end
+
+      # RSpec 1 & 2 use the same DRb call signature, and we can avoid loading a large chunk of fast_spec
+      # just to let DRb know what to do.
+      #
+      # For reference:
+      #
+      # * RSpec 1: https://github.com/myronmarston/rspec-1/blob/master/lib/spec/runner/drb_command_line.rb
+      # * RSpec 2: https://github.com/rspec/rspec-core/blob/master/lib/rspec/core/drb_command_line.rb
+      def drb_service(port)
+        require "drb/drb"
+
+        # Make sure we have a listener running
+        unless @drb_listener_running
+          begin
+            DRb.start_service("druby://localhost:0")
+          rescue SocketError, Errno::EADDRNOTAVAIL
+            DRb.start_service("druby://:0")
+          end
+
+          @drb_listener_running = true
+        end
+
+        @drb_services ||= {}
+        @drb_services[port.to_i] ||= DRbObject.new_with_uri("druby://127.0.0.1:#{port}")
+      end
+
+      def bundler_allowed?
+        if @bundler_allowed.nil?
+          @bundler_allowed = File.exist?("#{Dir.pwd}/Gemfile")
+        else
+          @bundler_allowed
+        end
+      end
+
+      def bundler?
+        if @bundler.nil?
+          @bundler = bundler_allowed? && @options[:bundler]
+        else
+          @bundler
+        end
+      end
+
+      def binstubs?
+        if @binstubs.nil?
+          @binstubs = bundler? && @options[:binstubs]
+        else
+          @binstubs
+        end
+      end
+
+      def determine_fast_spec_version
+        if File.exist?("#{Dir.pwd}/spec/spec_helper.rb")
+          File.new("#{Dir.pwd}/spec/spec_helper.rb").read.include?("Spec::Runner") ? 1 : 2
+        elsif bundler_allowed?
+          ENV['BUNDLE_GEMFILE'] = "#{Dir.pwd}/Gemfile"
+          `bundle show rspec`.include?("/rspec-1.") ? 1 : 2
+        else
+          2
+        end
+      end
+
+      def deprecations_warnings
+        [:color, :drb, [:fail_fast, "fail-fast"], [:formatter, "format"]].each do |option|
+          key, value = option.is_a?(Array) ? option : [option, option.to_s]
+          if @options.key?(key)
+            @options.delete(key)
+            UI.info %{DEPRECATION WARNING: The :#{key} option is deprecated. Pass standard command line argument "--#{value}" to FastSpec with the :cli option.}
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/guard/fast_spec/templates/Guardfile

@@ -0,0 +1,12 @@
+guard 'fast_spec', :cli => "-Ifast_specs -r turnip", :spec_paths => ["fast_specs"], :version => 2 do
+  watch(%r{^fast_specs/roles/.+_spec\.rb$})
+  watch(%r{^fast_specs/lib/(.+)\.rb$})     { |m| "fast_specs/lib/#{m[1]}_spec.rb" }
+
+  watch('fast_specs/spec_helper.rb')       { "fast_specs" }
+  watch(%r{^fast_specs/support/(.+)\.rb$}) { "fast_specs" }
+  watch(%r{^fast_specs/roles/(.+)\.rb$})   { |m| "fast_specs/roles/#{m[1]}.rb" }
+
+  watch(%r{^app/roles/(.+)\.rb$})          { |m| "fast_specs/roles/#{m[1]}_spec.rb" }
+end
+
+

data/lib/guard/fast_spec/version.rb

@@ -0,0 +1,5 @@
+module Guard
+  module FastSpecVersion
+    VERSION = "0.0.1"
+  end
+end

data/lib/guard/fast_spec.rb

@@ -0,0 +1,77 @@
+require 'guard'
+require 'guard/guard'
+
+module Guard
+  class FastSpec < Guard
+    autoload :Runner,    'guard/fast_spec/runner'
+    autoload :Inspector, 'guard/fast_spec/inspector'
+
+    def initialize(watchers = [], options = {})
+      super
+      @options = {
+        :all_after_pass => true,
+        :all_on_start   => true,
+        :keep_failed    => true,
+        :spec_paths     => ["fast_spec"],
+        :run_all        => {}
+      }.merge(options)
+      @last_failed  = false
+      @failed_paths = []
+
+      @inspector = Inspector.new(@options)
+      @runner    = Runner.new(@options)
+    end
+
+    # Call once when guard starts
+    def start
+      UI.info "Guard::FastSpec is running, with RSpec #{@runner.fast_spec_version}!"
+      run_all if @options[:all_on_start]
+    end
+
+    def run_all
+      passed = @runner.run(@options[:spec_paths], @options[:run_all].merge(:message => 'Running all fast_specs'))
+
+      unless @last_failed = !passed
+        @failed_paths = []
+      else
+        throw :task_has_failed
+      end
+    end
+
+    def reload
+      @failed_paths = []
+    end
+
+    def run_on_change(paths)
+      paths += @failed_paths if @options[:keep_failed]
+      paths  = @inspector.clean(paths)
+
+      if passed = @runner.run(paths)
+        remove_failed(paths)
+
+        # run all the specs if the run before this one failed
+        if @last_failed && @options[:all_after_pass]
+          @last_failed = false
+          run_all
+        end
+      else
+        @last_failed = true
+        add_failed(paths)
+
+        throw :task_has_failed
+      end
+    end
+
+  private
+
+    def remove_failed(paths)
+      @failed_paths -= paths if @options[:keep_failed]
+    end
+
+    def add_failed(paths)
+      @failed_paths += paths if @options[:keep_failed]
+    end
+
+  end
+end
+

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: guard-fast_spec
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Thibaud Guillaume-Gentil
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: &70139249986840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70139249986840
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70139249985560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: *70139249985560
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70139249983840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :development
+  prerelease: false
+  version_requirements: *70139249983840
+description: Guard::FastSpec automatically run your specs (much like autotest).
+email:
+- thibaud@thibaud.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/guard/fast_spec/formatter.rb
+- lib/guard/fast_spec/formatters/notification_rspec.rb
+- lib/guard/fast_spec/formatters/notification_spec.rb
+- lib/guard/fast_spec/inspector.rb
+- lib/guard/fast_spec/runner.rb
+- lib/guard/fast_spec/templates/Guardfile
+- lib/guard/fast_spec/version.rb
+- lib/guard/fast_spec.rb
+- LICENSE
+- README.md
+homepage: http://rubygems.org/gems/guard-fast_spec
+licenses: []
+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: 1.3.6
+requirements: []
+rubyforge_project: guard-fast_spec
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Guard gem for FastSpec (forked from guard-rspec)
+test_files: []