kuende-fakeredis 0.6.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 76c8f5456b0498e73104bfa6827a7d25a96d1b1c
-  data.tar.gz: a5443bdf8ae83d89a21cd5d5859e4a71c60327f0
+  metadata.gz: acc0ed06145e5a35f4b3c3628faa81569bbf46d1
+  data.tar.gz: 6a9a2d56687e918e9bcde704c67ec50afd05bb7c
 SHA512:
-  metadata.gz: 6c1160fc425e5d4c597e97c4b35229e31908ecfd1e43f569c1fb523af6acb29e2e9e52636cf7554212946f83f0c89044c37bb11d21d56dd749731e9c25b94c71
-  data.tar.gz: ae72a230bd9cecadd6511a60a2090f88465b07b7f34eb35fa536e6d99e74e404dfa8342d4ad3b278fa50f1fa72683836d4b5861ae97a9f4a0174dfbb036f2524
+  metadata.gz: cfd38f75adaa13bd05fd1c3870d25c2d59b1077a4c3fd5cb2781a885eec502864d519e416d5c913b7b60b81d0da12d76e3be27933098839454705fb73e1a3896
+  data.tar.gz: f0be187c75bafde58f77705355396c840a7ed9ad82b89b24a1825168ae9f181d9e2f9f31fef0c05d7de243ff2378c517abc15eeec525fec0a3c9dfb93b08246a

data/.gitignore

@@ -7,3 +7,4 @@ pkg/*
 *.rbc
 .ruby-version
 .ruby-gemset
+bin

data/.travis.yml

@@ -2,9 +2,10 @@ language: ruby
 before_install:
   - travis_retry gem install bundler
 rvm:
-  - 1.9.3
-  - 2.0.0
   - 2.1
+  - 2.2
+  - 2.3.1
+  - 2.4
   - ruby-head
   - jruby
   - rbx-2

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2014 Guillermo Iguaran
+Copyright (c) 2011-2016 Guillermo Iguaran
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -98,5 +98,5 @@ Or:
 
 ## Copyright
 
-Copyright (c) 2011-2014 Guillermo Iguaran. See LICENSE for
+Copyright (c) 2011-2016 Guillermo Iguaran. See LICENSE for
 further details.

data/fakeredis.gemspec

@@ -18,7 +18,6 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency(%q<redis>, ["~> 3.2"])
+  s.add_runtime_dependency "redis", ">= 3.3.5", "< 5.0"
   s.add_development_dependency(%q<rspec>, ["~> 3.0"])
-  s.add_development_dependency "guard-rspec"
 end

data/lib/fakeredis.rb

@@ -3,4 +3,16 @@ require 'redis/connection/memory'
 
 module FakeRedis
   Redis = ::Redis
+
+  def self.enable
+    Redis::Connection.drivers << Redis::Connection::Memory unless enabled?
+  end
+
+  def self.enabled?
+    Redis::Connection.drivers.last == Redis::Connection::Memory
+  end
+
+  def self.disable
+    Redis::Connection.drivers.delete_if {|driver| Redis::Connection::Memory == driver }
+  end
 end

data/lib/fakeredis/command_executor.rb

@@ -1,13 +1,16 @@
 module FakeRedis
   module CommandExecutor
     def write(command)
-      meffod = command.shift.to_s.downcase.to_sym
+      meffod = command[0].to_s.downcase.to_sym
+      args = command[1..-1]
 
       if in_multi && !(TRANSACTION_COMMANDS.include? meffod) # queue commands
-        queued_commands << [meffod, *command]
+        queued_commands << [meffod, *args]
         reply = 'QUEUED'
+      elsif respond_to?(meffod) && method(meffod).arity.zero?
+        reply = send(meffod)
       elsif respond_to?(meffod)
-        reply = send(meffod, *command)
+        reply = send(meffod, *args)
       else
         raise Redis::CommandError, "ERR unknown command '#{meffod}'"
       end

data/lib/fakeredis/sort_method.rb

@@ -101,7 +101,7 @@ module FakeRedis
       skip = limit.first || 0
       take = limit.last || sorted.length
 
-      sorted[skip...(skip + take)] || sorted
+      sorted[skip...(skip + take)] || []
     end
 
     def lookup_from_pattern(pattern, element)

data/lib/fakeredis/sorted_set_store.rb

@@ -68,7 +68,7 @@ module FakeRedis
 
   class SortedSetIntersectStore < SortedSetStore
     def selected_keys
-      @values ||= hashes.inject([]) { |r, h| r.empty? ? h.keys : (r & h.keys) }
+      @values ||= hashes.map(&:keys).reduce(:&)
     end
   end
 

data/lib/fakeredis/version.rb

@@ -1,3 +1,3 @@
 module FakeRedis
-  VERSION = "0.6.0"
+  VERSION = "0.10.0"
 end

data/lib/redis/connection/memory.rb

@@ -9,7 +9,6 @@ require "fakeredis/sorted_set_store"
 require "fakeredis/transaction_commands"
 require "fakeredis/zset"
 require "fakeredis/bitop_command"
-require "fakeredis/version"
 
 class Redis
   module Connection
@@ -90,6 +89,15 @@ class Redis
       def disconnect
       end
 
+      def client(command, options = {})
+        case command
+        when :setname then true
+        when :getname then nil
+        else
+          raise Redis::CommandError, "ERR unknown command '#{command}'"
+        end
+      end
+
       def timeout=(usecs)
       end
 
@@ -347,7 +355,14 @@ class Redis
 
       def lrange(key, startidx, endidx)
         data_type_check(key, Array)
-        (data[key] && data[key][startidx..endidx]) || []
+        if data[key]
+          # In Ruby when negative start index is out of range Array#slice returns
+          # nil which is not the case for lrange in Redis.
+          startidx = 0 if startidx < 0 && startidx.abs > data[key].size
+          data[key][startidx..endidx] || []
+        else
+          []
+        end
       end
 
       def ltrim(key, start, stop)
@@ -380,9 +395,9 @@ class Redis
         index = data[key].index(pivot.to_s)
         return -1 if index.nil?
 
-        case where
-          when :before then data[key].insert(index, value)
-          when :after  then data[key].insert(index + 1, value)
+        case where.to_s
+          when /\Abefore\z/i then data[key].insert(index, value)
+          when /\Aafter\z/i  then data[key].insert(index + 1, value)
           else raise_syntax_error
         end
       end
@@ -553,11 +568,14 @@ class Redis
         result
       end
 
-      def spop(key)
+      def spop(key, count = nil)
         data_type_check(key, ::Set)
-        elem = srandmember(key)
-        srem(key, elem)
-        elem
+        results = (count || 1).times.map do
+          elem = srandmember(key)
+          srem(key, elem)
+          elem
+        end.compact
+        count.nil? ? results.first : results
       end
 
       def scard(key)
@@ -620,6 +638,44 @@ class Redis
         number.nil? ? srandmember_single(key) : srandmember_multiple(key, number)
       end
 
+      def sscan(key, start_cursor, *args)
+        data_type_check(key, ::Set)
+        return ["0", []] unless data[key]
+
+        match = "*"
+        count = 10
+
+        if args.size.odd?
+          raise_argument_error('sscan')
+        end
+
+        if idx = args.index("MATCH")
+          match = args[idx + 1]
+        end
+
+        if idx = args.index("COUNT")
+          count = args[idx + 1]
+        end
+
+        start_cursor = start_cursor.to_i
+
+        cursor = start_cursor
+        next_keys = []
+
+        if start_cursor + count >= data[key].length
+          next_keys = (data[key].to_a)[start_cursor..-1]
+          cursor = 0
+        else
+          cursor = start_cursor + count
+          next_keys = (data[key].to_a)[start_cursor..cursor-1]
+        end
+
+        filtered_next_keys = next_keys.select{ |k,v| File.fnmatch(match, k)}
+        result = filtered_next_keys.flatten.map(&:to_s)
+
+        return ["#{cursor}", result]
+      end
+
       def del(*keys)
         keys = keys.flatten(1)
         raise_argument_error('del') if keys.empty?
@@ -735,6 +791,7 @@ class Redis
             data[key][field[0].to_s] = field[1].to_s
           end
         end
+        "OK"
       end
 
       def hmget(key, *fields)
@@ -914,10 +971,6 @@ class Redis
         match = "*"
         count = 10
 
-        if args.size.odd?
-          raise_argument_error('scan')
-        end
-
         if idx = args.index("MATCH")
           match = args[idx + 1]
         end
@@ -927,20 +980,25 @@ class Redis
         end
 
         start_cursor = start_cursor.to_i
-        data_type_check(start_cursor, Fixnum)
+        data_type_check(start_cursor, Integer)
 
         cursor = start_cursor
-        next_keys = []
+        returned_keys = []
+        final_page = start_cursor + count >= keys(match).length
+
+        if final_page
+          previous_keys_been_deleted = (count >= keys(match).length)
+          start_index = previous_keys_been_deleted ? 0 : cursor
 
-        if start_cursor + count >= data.length
-          next_keys = keys(match)[start_cursor..-1]
+          returned_keys = keys(match)[start_index..-1]
           cursor = 0
         else
-          cursor = start_cursor + 10
-          next_keys = keys(match)[start_cursor..cursor]
+          end_index = start_cursor + (count - 1)
+          returned_keys = keys(match)[start_cursor..end_index]
+          cursor = start_cursor + count
         end
 
-        return "#{cursor}", next_keys
+        return "#{cursor}", returned_keys
       end
 
       def zadd(key, *args)
@@ -1032,7 +1090,7 @@ class Redis
         results = sort_keys(data[key])
         # Select just the keys unless we want scores
         results = results.map(&:first) unless with_scores
-        results[start..stop].flatten.map(&:to_s)
+        (results[start..stop] || []).flatten.map(&:to_s)
       end
 
       def zrangebylex(key, start, stop, *opts)
@@ -1241,7 +1299,7 @@ class Redis
         end
 
         start_cursor = start_cursor.to_i
-        data_type_check(start_cursor, Fixnum)
+        data_type_check(start_cursor, Integer)
 
         cursor = start_cursor
         next_keys = []
@@ -1372,4 +1430,5 @@ class Redis
   end
 end
 
+# FIXME this line should be deleted as explicit enabling is better
 Redis::Connection.drivers << Redis::Connection::Memory

data/spec/command_executor_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+RSpec.describe FakeRedis::CommandExecutor do
+  
+  let(:redis) { Redis.new }
+
+  context '#write' do
+    it 'does not modify its argument' do
+      command = [:get, 'key']
+      redis.write(command)
+      expect(command).to eql([:get, 'key'])
+    end
+  end
+
+end

data/spec/fakeredis_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe FakeRedis do
+  after { described_class.disable }
+
+  describe '.enable' do
+    it 'in memory connection' do
+      described_class.enable
+      expect(described_class.enabled?).to be_truthy
+    end
+  end
+
+  describe '.disable' do
+    before { described_class.enable }
+
+    it 'in memory connection' do
+      described_class.disable
+      expect(described_class.enabled?).to be_falsy
+    end
+  end
+end

data/spec/hashes_spec.rb

@@ -137,6 +137,10 @@ module FakeRedis
       expect { @client.hmset("hash", "foo1", "bar1", "foo2", "bar2", "foo3") }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for HMSET")
     end
 
+    it "should return OK on success" do
+      expect(@client.hmset("key", "k1", "value1")).to eq("OK")
+    end
+
     it "should set multiple hash fields to multiple values" do
       @client.hmset("key", "k1", "value1", "k2", "value2")
 

data/spec/lists_spec.rb

@@ -25,6 +25,18 @@ module FakeRedis
       expect(@client.lrange("key1", 0, -1)).to eq(["v1", "v2", "v3", "99", "100"])
     end
 
+    it "inserts with case-insensitive position token" do
+      @client.rpush("key1", "v1")
+      @client.rpush("key1", "v4")
+
+      @client.linsert("key1", :BEFORE, "v4", "v2")
+      @client.linsert("key1", "Before", "v4", "v3")
+      @client.linsert("key1", :AFTER, "v4", "v5")
+      @client.linsert("key1", "After", "v5", "v6")
+
+      expect(@client.lrange("key1", 0, -1)).to eq(%w(v1 v2 v3 v4 v5 v6))
+    end
+
     it "should not insert if after/before index not found" do
       @client.rpush("key", "v1")
       expect(@client.linsert("key", :before, "unknown", "v2")).to eq(-1)
@@ -89,6 +101,7 @@ module FakeRedis
       @client.rpush("key1", "v3")
 
       expect(@client.lrange("key1", 1, -1)).to eq(["v2", "v3"])
+      expect(@client.lrange("key1", -999, -1)).to eq(["v1", "v2", "v3"])
     end
 
     it "should remove elements from a list" do

data/spec/memory_spec.rb

@@ -1,28 +1,101 @@
 require 'spec_helper'
 
-module FakeRedis
+RSpec.describe FakeRedis do
+  let(:redis) { Redis.new }
+
+  def populate_keys_in_redis(num)
+    num.times do |count|
+      redis.set("key#{count}", count)
+    end
+  end
+
+  describe '#write' do
+    it 'should not send unexpected arguments' do
+      expect { redis.write(['info', 'server']) }.not_to raise_error
+    end
+  end
+
+  describe '#scan' do
+    def result
+      returned_keys = []
+      cursor = 0
+
+      loop do
+        cursor, keys = redis.scan(cursor, match_arguments)
+        returned_keys += keys
+        break if cursor == '0'
+      end
+      returned_keys
+    end
+
+    before do
+      populate_keys_in_redis(11)
+    end
+
+    context('when deleting') do
+      it('preverves cursor') do
+        cursor, keys = redis.scan('0')
+        keys.each { |key| redis.del(key) }
+        _, keys = redis.scan(cursor)
+        expect(keys).to eq(%w(key10))
+      end
+    end
+
+    context 'with one namespace' do
+      let(:match_arguments) { {} }
+
+      it 'returns the expected array of keys' do
+        expect(result).to match_array(redis.keys)
+      end
+    end
+
+    context 'with multiple namespaces' do
+      let(:namespaced_key) { 'test' }
+      let(:match_arguments) { { match: namespaced_key } }
+
+      before { redis.set(namespaced_key, 12) }
+
+      it 'returns the expected array of keys' do
+        expect(result).to match_array([namespaced_key])
+      end
+    end
+  end
+
   describe 'time' do
     before(:each) do
-      @client = Redis.new
       allow(Time).to receive_message_chain(:now, :to_f).and_return(1397845595.5139461)
     end
 
     it 'is an array' do
-      expect(@client.time).to be_an_instance_of(Array)
+      expect(redis.time).to be_an_instance_of(Array)
     end
 
     it 'has two elements' do
-      expect(@client.time.count).to eql 2
+      expect(redis.time.count).to eql 2
     end
 
     if fakeredis?
       it 'has the current time in seconds' do
-        expect(@client.time.first).to eql 1397845595
+        expect(redis.time.first).to eql 1397845595
       end
 
       it 'has the current leftover microseconds' do
-        expect(@client.time.last).to eql 513946
+        expect(redis.time.last).to eql 513946
       end
     end
   end
+
+  describe '#client' do
+    it 'returns 1 when command is :setname' do
+      expect(redis.write([:client, :setname])).to eq 1
+    end
+
+    it 'returns nil when command is :getname' do
+      expect(redis.write([:client, :getname])).to eq nil
+    end
+
+    it 'raises error for other commands' do
+      expect { redis.write([:client, :wrong]) }.to raise_error(Redis::CommandError, "ERR unknown command 'wrong'")
+    end
+  end
 end

data/spec/sets_spec.rb

@@ -148,6 +148,22 @@ module FakeRedis
       expect(["a", "b"].include?(@client.spop("key1"))).to be true
     end
 
+    it "should pop multiple members from a set" do
+      @client.sadd("key1", "a")
+      @client.sadd("key1", "b")
+      @client.sadd("key1", "c")
+
+      vals = @client.spop("key1", 2)
+      expect(vals.count).to eq(2)
+      vals.each { |v| expect(["a", "b", "c"].include?(v)).to be true }
+
+      new_vals = @client.spop("key1", 2)
+      expect(new_vals.count).to eq(1)
+      expect(["a", "b", "c"].include?(new_vals.first)).to be true
+
+      expect(["a", "b", "c"]).to eq((vals + new_vals).sort)
+    end
+
     it "should remove a member from a set" do
       @client.sadd("key1", "a")
       @client.sadd("key1", "b")
@@ -276,5 +292,43 @@ module FakeRedis
         expect(@client.srandmember("key1", 1)).to eq([])
       end
     end
+
+    describe "#sscan" do
+      it 'with no arguments and few items, returns all items' do
+        @client.sadd('set', ['name', 'Jack', 'age', '33'])
+        result = @client.sscan('set', 0)
+
+        expect(result[0]).to eq('0')
+        expect(result[1]).to eq(['name', 'Jack', 'age', '33'])
+      end
+
+      it 'with a count should return that number of members or more' do
+        @client.sadd('set', ['a', '1', 'b', '2', 'c', '3', 'd', '4', 'e', '5', 'f', '6', 'g', '7'])
+        result = @client.sscan('set', 0, count: 3)
+        expect(result[0]).to eq('3')
+        expect(result[1]).to eq([ 'a', '1', 'b'])
+      end
+
+      it 'returns items starting at the provided cursor' do
+        @client.sadd('set', ['a', '1', 'b', '2', 'c', '3', 'd', '4', 'e', '5', 'f', '6', 'g', '7'])
+        result = @client.sscan('set', 2, count: 3)
+        expect(result[0]).to eq('5')
+        expect(result[1]).to eq(['b', '2', 'c'])
+      end
+
+      it 'with match, returns items matching the given pattern' do
+        @client.sadd('set', ['aa', '1', 'b', '2', 'cc', '3', 'd', '4', 'ee', '5', 'f', '6', 'gg', '7'])
+        result = @client.sscan('set', 2, count: 7, match: '??')
+        expect(result[0]).to eq('9')
+        expect(result[1]).to eq(['cc','ee'])
+      end
+
+      it 'returns an empty result if the key is not found' do
+        result = @client.sscan('set', 0)
+
+        expect(result[0]).to eq('0')
+        expect(result[1]).to eq([])
+      end
+    end
   end
 end

data/spec/sorted_sets_spec.rb

@@ -306,6 +306,22 @@ module FakeRedis
       it "should error with an invalid aggregate" do
         expect { @client.zinterstore("out", %w(key1 key2), :aggregate => :invalid) }.to raise_error(Redis::CommandError, "ERR syntax error")
       end
+
+      it 'stores nothing when there are no members in common' do
+        @client.zadd("k1", 1, "1")
+        @client.zadd("k1", 1, "2")
+        @client.sadd("k2", "a")
+        @client.sadd("k3", "b")
+
+        expect(@client.zinterstore("out", %w(k1 k2 k3))).to eq(0)
+        expect(@client.zrange("out", 0, -1)).to eq([])
+      end
+
+      it 'handles range start being higher than number of members' do
+        @client.zadd("key", 1, "1")
+
+        expect(@client.zrange("key", 10, 10)).to eq([])
+      end
     end
 
     context "zremrangebyscore" do

data/spec/spec_helper.rb

@@ -7,7 +7,11 @@ require "fakeredis/rspec"
 require "support/shared_examples/sortable"
 require "support/shared_examples/bitwise_operation"
 
+
 RSpec.configure do |config|
+  # Enable memory adapter
+  config.before(:each) { FakeRedis.enable }
+
   # replaces -b -fdoc --color in .rspec
   config.color = true
   config.default_formatter = "doc"
@@ -25,5 +29,5 @@ RSpec.configure do |config|
 end
 
 def fakeredis?
-  true
+  FakeRedis.enabled?
 end

data/spec/spec_helper_live_redis.rb

@@ -1,14 +1,14 @@
 require "spec_helper"
 
-# Remove memory so we test against actual redis
-Redis::Connection.drivers.pop
-
 RSpec.configure do |config|
   config.before(:each) do
+    # Disable so we test against actual redis
+    FakeRedis.disable
+
     Redis.new.flushall
   end
 end
 
 def fakeredis?
-  false
+  FakeRedis.enabled?
 end

data/spec/support/shared_examples/sortable.rb

@@ -53,6 +53,10 @@ shared_examples_for "a sortable" do
     it 'only returns requested window in the enumerable' do
       expect(@client.sort(@key, :limit => [0, 1])).to eq(['1'])
     end
+
+    it 'returns an empty array if the offset if more than the length of the list' do
+      expect(@client.sort(@key, :limit => [3, 1])).to eq([])
+    end
   end
 
   context 'store' do

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: kuende-fakeredis
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Guillermo Iguaran
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-14 00:00:00.000000000 Z
+date: 2017-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.3.5
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: 3.3.5
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -38,20 +44,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: guard-rspec
-  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'
 description: Fake (In-memory) driver for redis-rb. Useful for testing environment
   and machines without Redis.
 email:
@@ -63,7 +55,6 @@ files:
 - ".gitignore"
 - ".travis.yml"
 - Gemfile
-- Guardfile
 - LICENSE
 - README.md
 - Rakefile
@@ -84,8 +75,10 @@ files:
 - lib/fakeredis/zset.rb
 - lib/redis/connection/memory.rb
 - spec/bitop_command_spec.rb
+- spec/command_executor_spec.rb
 - spec/compatibility_spec.rb
 - spec/connection_spec.rb
+- spec/fakeredis_spec.rb
 - spec/hashes_spec.rb
 - spec/keys_spec.rb
 - spec/lists_spec.rb
@@ -122,14 +115,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Fake (In-memory) driver for redis-rb.
 test_files:
 - spec/bitop_command_spec.rb
+- spec/command_executor_spec.rb
 - spec/compatibility_spec.rb
 - spec/connection_spec.rb
+- spec/fakeredis_spec.rb
 - spec/hashes_spec.rb
 - spec/keys_spec.rb
 - spec/lists_spec.rb

data/Guardfile

@@ -1,8 +0,0 @@
-ignore([%r{^bin/*}, %r{^lib/*}, %r{^tmp/*}])
-
-guard 'rspec', cmd: 'bundle exec rspec', all_after_pass: false, all_on_start: false do
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})                           { |m| "spec/lib/#{m[1]}_spec.rb" }
-  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
-  watch('spec/spec_helper.rb')                        { "spec" }
-end