redis-copy 0.0.5 → 0.0.6

data/.gitignore

@@ -14,4 +14,5 @@ rdoc
 spec/reports
 test/tmp
 test/version_tmp
+spec/db
 tmp

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+script: "bundle exec rake run"
+
+rvm:
+  - 1.9.3
+gemfile:
+  - .travis/Gemfile.redis-gem-3.0
+  - .travis/Gemfile.redis-gem-master
+env:
+  global:
+    - TIMEOUT=1
+  matrix:
+    - REDIS_BRANCH=2.4
+    - REDIS_BRANCH=2.6
+    - REDIS_BRANCH=2.8
+    - REDIS_BRANCH=unstable

data/.travis/Gemfile.redis-gem-3.0

@@ -0,0 +1,6 @@
+# encoding: utf-8
+source 'https://rubygems.org'
+
+gem 'redis', '~> 3.0'
+
+gemspec :path => '../'

data/.travis/Gemfile.redis-gem-3.0.lock

@@ -0,0 +1,44 @@
+PATH
+  remote: ../
+  specs:
+    redis-copy (0.0.5)
+      activesupport
+      redis
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.0.1)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    atomic (1.1.14)
+    diff-lcs (1.2.5)
+    i18n (0.6.5)
+    minitest (4.7.5)
+    multi_json (1.8.2)
+    rake (10.1.0)
+    redis (3.0.5)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    thread_safe (0.1.3)
+      atomic
+    tzinfo (0.3.38)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  rake
+  redis (~> 3.0)
+  redis-copy!
+  rspec (~> 2.14)

data/.travis/Gemfile.redis-gem-master

@@ -0,0 +1,6 @@
+# encoding: utf-8
+source 'https://rubygems.org'
+
+gem 'redis', :git => 'https://github.com/redis/redis-rb.git'
+
+gemspec :path => '../'

data/.travis/Gemfile.redis-gem-master.lock

@@ -0,0 +1,49 @@
+GIT
+  remote: https://github.com/redis/redis-rb.git
+  revision: 9bb4156dcd43105b68e24e5efc579dddb12cf260
+  specs:
+    redis (3.0.6)
+
+PATH
+  remote: ../
+  specs:
+    redis-copy (0.0.5)
+      activesupport
+      redis
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.0.1)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    atomic (1.1.14)
+    diff-lcs (1.2.5)
+    i18n (0.6.5)
+    minitest (4.7.5)
+    multi_json (1.8.2)
+    rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    thread_safe (0.1.3)
+      atomic
+    tzinfo (0.3.38)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  rake
+  redis!
+  redis-copy!
+  rspec (~> 2.14)

data/README.md

@@ -24,7 +24,7 @@ $ redis-copy --help
 redis-copy v0.0.5
 Usage: redis-copy [options] <source> <destination>
     <source> and <destination> must be redis connection uris
-    like [redis://]<hostname>[:<port>][/<db>]
+    like [redis://][<username>:<password>@]<hostname>[:<port>][/<db>]
 
 Specific options:
         --strategy STRATEGY          Select strategy (auto, new, classic) (default auto)

data/Rakefile

@@ -7,3 +7,63 @@ RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList['spec/**/*_spec.rb']
   spec.verbose = true
 end
+
+
+# STOLEN NEARLY VERBATIM FROM MIT-LICENSED REDIS-RB
+# https://github.com/redis/redis-rb
+require 'rubygems'
+
+ENV["REDIS_BRANCH"] ||= "unstable"
+
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'redis/version'
+
+REDIS_DIR = File.expand_path(File.join("..", "spec"), __FILE__)
+REDIS_CNF = File.join(REDIS_DIR, "redis.spec.conf")
+REDIS_PID = File.join(REDIS_DIR, "db", "redis.pid")
+BINARY = "tmp/redis-#{ENV["REDIS_BRANCH"]}/src/redis-server"
+
+task :default => :run
+
+desc "Run tests and manage server start/stop"
+task :run => [:start, :spec, :stop]
+
+desc "Start the Redis server"
+task :start => BINARY do
+  sh "#{BINARY} --version"
+
+  redis_running = \
+  begin
+    File.exists?(REDIS_PID) && Process.kill(0, File.read(REDIS_PID).to_i)
+  rescue Errno::ESRCH
+    FileUtils.rm REDIS_PID
+    false
+  end
+
+  unless redis_running
+    unless system("#{BINARY} #{REDIS_CNF}")
+      abort "could not start redis-server"
+    end
+  end
+end
+
+desc "Stop the Redis server"
+task :stop do
+  if File.exists?(REDIS_PID)
+    Process.kill "INT", File.read(REDIS_PID).to_i
+    FileUtils.rm REDIS_PID
+  end
+end
+
+file BINARY do
+  branch = ENV.fetch("REDIS_BRANCH")
+
+  sh <<-SH
+  mkdir -p tmp;
+  cd tmp;
+  wget https://github.com/antirez/redis/archive/#{branch}.tar.gz -O #{branch}.tar.gz;
+  tar xf #{branch}.tar.gz;
+  cd redis-#{branch};
+  make
+  SH
+end

data/lib/redis-copy.rb

@@ -93,8 +93,13 @@ module RedisCopy
       host = uri.host
       port = uri.port if uri.port
       db = uri.path ? uri.path[1..-1].to_i : 0
+      password = uri.password
 
-      Redis.new(host: host, port: port, db: db)
+      # Connect & Ping to ensure access.
+      Redis.new(host: host, port: port, db: db, password: password).tap(&:ping)
+    rescue Redis::CommandError => e
+      fail(Redis::CommandError,
+           "There was a problem connecting to #{uri.to_s}\n#{e.message}")
     end
   end
 end

data/lib/redis-copy/cli.rb

@@ -5,10 +5,10 @@ require 'optparse'
 
 module RedisCopy
   class CLI
-    REDIS_URI = (/\A(?:redis:\/\/)?([a-z0-9\-.]+)(:[0-9]{1,5})?(\/(?:(?:1[0-5])|[0-9]))?\z/i).freeze
+    REDIS_URI = (/\A(?:redis:\/\/)?(\w*:\w+@)?([a-z0-9\-.]+)(:[0-9]{1,5})?(\/(?:(?:1[0-5])|[0-9]))?\z/i).freeze
     DEFAULTS = {
       ui:             :command_line,
-      key_emitter:    :default,
+      key_emitter:    :auto,
       strategy:       :auto,
       verify:         0,
       pipeline:       :true,
@@ -25,7 +25,7 @@ module RedisCopy
 
       OptionParser.new do |opts|
         opts.version = RedisCopy::VERSION
-        opts.banner = "#{opts.program_name} v#{opts.version}\n" +
+        opts.banner = "#{opts.program_name} v#{opts.version} (with redis-rb #{Redis::VERSION})\n" +
                       "Usage: #{opts.program_name} [options] <source> <destination>"
 
         indent_desc = proc do |desc|
@@ -33,7 +33,7 @@ module RedisCopy
         end
 
         opts.separator "    <source> and <destination> must be redis connection uris"
-        opts.separator "    like [redis://]<hostname>[:<port>][/<db>]"
+        opts.separator "    like [redis://][<username>:<password>@]<hostname>[:<port>][/<db>]"
         opts.separator ''
         opts.separator "Specific options:"
 
@@ -48,6 +48,17 @@ module RedisCopy
           options[:strategy] = strategy
         end
 
+        opts.on('--emitter EMITTER', [:auto, :scan, :keys],
+          indent_desc.(
+            "Select key emitter (auto, keys, scan) (default #{DEFAULTS[:strategy]})\n" +
+            "  auto:    uses scan if available, otherwise fallback\n" +
+            "  scan:    use redis SCAN command (faster, less blocking)\n" +
+            "  keys:    uses redis KEYS command (dangerous, esp. on large datasets)"
+          )
+        ) do |emitter|
+          options[:key_emitter] = emitter
+        end
+
         opts.on('--[no-]pipeline',
           "Use redis pipeline where available (default #{DEFAULTS[:pipeline]})"
         ) do |pipeline|

data/lib/redis-copy/key-emitter.rb

@@ -9,9 +9,15 @@ module RedisCopy
   module KeyEmitter
     def self.load(redis, ui, options = {})
       key_emitter = options.fetch(:key_emitter, :default)
-      const_name = key_emitter.to_s.camelize
-      require "redis-copy/key-emitter/#{key_emitter}" unless const_defined?(const_name)
-      const_get(const_name).new(redis, ui, options)
+      scan_compatible = Scan::compatible?(redis)
+      emitklass = case key_emitter
+                  when :keys then Keys
+                  when :scan
+                    raise ArgumentError unless scan_compatible
+                    Scan
+                  when :auto then scan_compatible ? Scan : Keys
+                  end
+      emitklass.new(redis, ui, options)
     end
 
     # @param redis [Redis]
@@ -37,7 +43,7 @@ module RedisCopy
     end
 
     # The default strategy blindly uses `redis.keys('*')`
-    class Default
+    class Keys
       include KeyEmitter
 
       def keys
@@ -66,6 +72,27 @@ module RedisCopy
         @ui.debug "REDIS: #{@redis.client.id} KEYS *"
         @redis.keys('*').to_enum
       end
+
+      def self.compatible?(redis)
+        true
+      end
+    end
+
+    class Scan
+      include KeyEmitter
+
+      def keys
+        @redis.scan_each(count: 1000)
+      end
+
+      def self.compatible?(redis)
+        bin_version = Gem::Version.new(redis.info['redis_version'])
+        bin_requirement = Gem::Requirement.new('>= 2.7.105')
+
+        return false unless bin_requirement.satisfied_by?(bin_version)
+
+        redis.respond_to?(:scan_each)
+      end
     end
   end
 end

data/lib/redis-copy/strategy/classic.rb

@@ -1,5 +1,36 @@
 # encoding: utf-8
 
+# The Classic strategy borrows *heavily* from the utils/redis-copy.rb found
+# in Redis source, which is also the inspiration for this gem.
+#
+# #{REDIS}/utils/redis-copy.rb - Copyright © 2009-2010 Salvatore Sanfilippo.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+#  * Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+#  * Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+#  * Neither the name of Redis nor the names of its contributors may
+#    be used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
 module RedisCopy
   module Strategy
     class Classic
@@ -51,7 +82,11 @@ module RedisCopy
           vs_zset = @src.zrange(key, 0, -1, :with_scores => true)
           sv_zset = vs_zset.map(&:reverse)
           @dst.zadd(key, sv_zset)
+        when 'none'
+          @ui.warn("GONE: #{key.dump}")
+          return false
         else
+          @ui.warn("UNKNOWN(#{vtype}): #{key.dump}")
           return false
         end
 
@@ -71,6 +106,10 @@ module RedisCopy
       def pipeline_enabled?
         @pipeline_enabled ||= (false | @opt[:pipeline])
       end
+
+      def self.compatible?(redis)
+        true
+      end
     end
   end
 end

data/lib/redis-copy/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module RedisCopy
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end

data/redis-copy.gemspec

@@ -8,13 +8,12 @@ Gem::Specification.new do |spec|
   spec.name          = 'redis-copy'
   spec.version       = RedisCopy::VERSION
 
-  authors_and_emails = [['Ryan Biesemeyer', 'ryan@yaauie.com']]
-  # authors_and_emails = (`sh git shortlog -sne`).lines.map do |l|
-  #   (/(?<=\t)(.+) <(.+)>\z/).match(l.chomp).last(2)
-  # end.compact.map(&:to_a)
+  authors_and_emails = (`git shortlog -sne`).lines.map do |l|
+    (/(?<=\t)(.+) <(.+)>\z/).match(l.chomp).to_a.last(2)
+  end.compact.map(&:to_a)
 
   spec.authors       = authors_and_emails.map(&:first)
-  spec.email         = authors_and_emails.map(&:last)
+  spec.email         = ['redis-copy@yaauie.com']
   spec.summary       = 'Copy the contents of one redis db to another'
   spec.description   = 'A command-line utility built for copying the ' +
                        'contents of one redis db to another over a ' +

data/spec/redis-copy/key-emitter_spec.rb

@@ -1,51 +1,67 @@
 # encoding: utf-8
 require 'redis-copy'
+require_relative '../spec_helper.rb'
 
-describe RedisCopy::KeyEmitter::Default do
-  let(:redis) { double }
+shared_examples_for RedisCopy::KeyEmitter do
+  let(:emitter_klass) { described_class }
+  let(:redis) { Redis.new(REDIS_OPTIONS) }
   let(:ui) { double.as_null_object }
-  let(:instance) { RedisCopy::KeyEmitter::Default.new(redis, ui)}
-  let(:connection_uri) { 'redis://12.34.56.78:9000/15' }
-  let(:key_count) { 100_000 }
+  let(:instance) { emitter_klass.new(redis, ui)}
+  let(:key_count) { 1 }
+  let(:keys) { key_count.times.map{|i| i.to_s(16) } }
 
   before(:each) do
-    redis.stub_chain('client.id').and_return(connection_uri)
-    redis.stub(:dbsize) { key_count }
+    unless emitter_klass.compatible?(redis)
+      pending "#{emitter_klass} not supported in your environment"
+    end
+    key_count.times.each_slice(50) do |keys|
+      kv = keys.map{|x| x.to_s(16)}.zip(keys)
+      redis.mset(*kv.flatten)
+    end
     ui.stub(:debug).with(anything)
   end
+  after(:each) { redis.flushdb }
 
   context '#keys' do
-    let(:mock_return) { ['foo:bar', 'asdf:qwer'] }
-    before(:each) do
-      redis.should_receive(:keys).with('*').exactly(:once).and_return(mock_return)
-    end
+    let(:key_count) { 64 }
     context 'the result' do
       subject { instance.keys }
-      its(:to_a) { should eq mock_return }
+      its(:to_a) { should =~ keys }
     end
-    context 'the supplied ui' do
-      it 'should get a debug message' do
-        ui.should_receive(:debug).
-          with(/#{Regexp.escape(connection_uri)} KEYS \*/).
-          exactly(:once)
-        instance.keys
-      end
-      context 'when source has > 10,000 keys' do
-        let(:key_count) { 100_000 }
-        it 'should ask for confirmation' do
-          ui.should_receive(:confirm?) do |confirmation|
-            confirmation.should match /\b100,000\b/
-          end
+  end
+end
+
+describe RedisCopy::KeyEmitter::Keys do
+  it_should_behave_like RedisCopy::KeyEmitter do
+    context '#keys' do
+      context 'the supplied ui' do
+        it 'should get a debug message' do
+          ui.should_receive(:debug).
+            with(/#{redis.client.id} KEYS \*/).
+            exactly(:once)
           instance.keys
         end
-      end
-      context 'when source has <= 10,000 keys' do
-        let(:key_count) { 1_000 }
-        it 'should not ask for confirmation' do
-          ui.should_not_receive(:confirm?)
-          instance.keys
+        context 'when source has > 10,000 keys' do
+          let(:key_count) { 10_001 }
+          it 'should ask for confirmation' do
+            ui.should_receive(:confirm?) do |confirmation|
+              confirmation.should match /\b10,001/
+            end
+            instance.keys
+          end
+        end
+        context 'when source has <= 10,000 keys' do
+          let(:key_count) { 1_000 }
+          it 'should not ask for confirmation' do
+            ui.should_not_receive(:confirm?)
+            instance.keys
+          end
         end
       end
     end
   end
 end
+
+describe RedisCopy::KeyEmitter::Scan do
+  it_should_behave_like RedisCopy::KeyEmitter
+end

data/spec/redis-copy/strategy_spec.rb

@@ -1,40 +1,10 @@
 # encoding: utf-8
-class RedisMultiplex < Struct.new(:source, :destination)
-  ResponseError = Class.new(RuntimeError)
-
-  def ensure_same!(&blk)
-    responses = {
-      source:      capture_result(source, &blk),
-      destination: capture_result(destination, &blk)
-    }
-    unless responses[:source] == responses[:destination]
-      raise ResponseError.new(responses.to_s)
-    end
-    case responses[:destination].first
-    when :raised then raise responses[:destination].last
-    when :returned then return responses[:destination].last
-    end
-  end
-  alias_method :both!, :ensure_same!
-
-  def both(&blk)
-    both!(&blk)
-    true
-  rescue ResponseError
-    false
-  end
-
-  def capture_result(redis, &block)
-    return [:returned, block.call(redis)]
-  rescue Object => exception
-    return [:raised, exception]
-  end
-end
+require_relative '../spec_helper'
 
 shared_examples_for(:no_ttl) do
   # key, redis,
   subject { redis.ttl(key) }
-  it { should eq -1 }
+  it { should be < 0 }
 end
 
 shared_examples_for(:ttl_set) do
@@ -56,10 +26,25 @@ shared_examples_for '#verify?' do
 end
 
 shared_examples_for(RedisCopy::Strategy) do
+  let(:strategy_class) { described_class }
+  let(:options) { Hash.new } # append using before(:each) { options.update(foo: true) }
+  # let(:ui) { double.as_null_object }
+  let(:ui) { RedisCopy::UI::CommandLine.new(options) }
+  let(:strategy) { strategy_class.new(source, destination, ui, options)}
+  let(:multiplex) { RedisMultiplex.new(source, destination) }
+  let(:source) { Redis.new(REDIS_OPTIONS.merge(db: 14)) }
+  let(:destination) { Redis.new(REDIS_OPTIONS.merge(db: 15)) }
+
   let(:key) { rand(16**128).to_s(16) }
   after(:each) { multiplex.both { |redis| redis.del(key) } }
   let(:ttl) { 100 }
 
+  before(:each) do
+    unless [source, destination].all?{|redis| strategy_class.compatible?(redis) }
+      pending "#{strategy_class} not supported in your environment"
+    end
+  end
+
   context '#copy' do
     before(:each) { populate.call }
     context 'string' do
@@ -301,22 +286,13 @@ shared_examples_for(RedisCopy::Strategy) do
   end
 end
 
-describe RedisCopy::Strategy do
-  let(:options) { Hash.new } # append using before(:each) { options.update(foo: true) }
-  # let(:ui) { double.as_null_object }
-  let(:ui) { RedisCopy::UI::CommandLine.new(options) }
-  let(:strategy) { strategy_class.new(source, destination, ui, options)}
-  let(:multiplex) { RedisMultiplex.new(source, destination) }
-  let(:source) { Redis.new(db: 14) }
-  let(:destination) { Redis.new(db: 15) }
 
-  describe :New do
-    let(:strategy_class) { RedisCopy::Strategy::New }
-    it_should_behave_like RedisCopy::Strategy
-  end
-  describe :Classic do
-    let(:strategy_class) { RedisCopy::Strategy::Classic }
-    it_should_behave_like RedisCopy::Strategy
+describe RedisCopy::Strategy::New do
+  it_should_behave_like RedisCopy::Strategy
+end
+
+describe RedisCopy::Strategy::Classic do
+  it_should_behave_like RedisCopy::Strategy do
     context '#maybe_pipeline' do
       it 'should not pipeline' do
         source.should_not_receive(:pipelined)

data/spec/redis.spec.conf

@@ -0,0 +1,9 @@
+dir ./spec/db
+pidfile ./redis.pid
+port 6381
+unixsocket ./redis.sock
+timeout 300
+loglevel debug
+logfile stdout
+databases 16
+daemonize yes

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+REDIS_PORT    = 6381
+REDIS_OPTIONS = { 
+  :port     => REDIS_PORT, 
+  :db       => 14,
+  :timeout  => Float(ENV["TIMEOUT"] || 0.1),
+}
+
+class RedisMultiplex < Struct.new(:source, :destination)
+  ResponseError = Class.new(RuntimeError)
+
+  def ensure_same!(&blk)
+    responses = {
+      source:      capture_result(source, &blk),
+      destination: capture_result(destination, &blk)
+    }
+    unless responses[:source] == responses[:destination]
+      raise ResponseError.new(responses.to_s)
+    end
+    case responses[:destination].first
+    when :raised then raise responses[:destination].last
+    when :returned then return responses[:destination].last
+    end
+  end
+  alias_method :both!, :ensure_same!
+
+  def both(&blk)
+    both!(&blk)
+    true
+  rescue ResponseError
+    false
+  end
+
+  def capture_result(redis, &block)
+    return [:returned, block.call(redis)]
+  rescue Object => exception
+    return [:raised, exception]
+  end
+end

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: redis-copy
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
 - Ryan Biesemeyer
+- Denis Goeury
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-01 00:00:00.000000000 Z
+date: 2013-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -95,13 +96,18 @@ description: A command-line utility built for copying the contents of one redis
   to another over a network. Supports all data types, persists ttls, and attempts
   to be as efficient as possible.
 email:
-- ryan@yaauie.com
+- redis-copy@yaauie.com
 executables:
 - redis-copy
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
+- .travis/Gemfile.redis-gem-3.0
+- .travis/Gemfile.redis-gem-3.0.lock
+- .travis/Gemfile.redis-gem-master
+- .travis/Gemfile.redis-gem-master.lock
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -120,8 +126,11 @@ files:
 - lib/redis-copy/version.rb
 - redis-copy.gemspec
 - redis-copy_spec.rb
+- spec/db/.gitkeep
 - spec/redis-copy/key-emitter_spec.rb
 - spec/redis-copy/strategy_spec.rb
+- spec/redis.spec.conf
+- spec/spec_helper.rb
 homepage: https://github.com/yaauie/redis-copy
 licenses:
 - MIT
@@ -135,12 +144,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 2506344141455451823
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 2506344141455451823
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -148,6 +163,8 @@ signing_key:
 specification_version: 3
 summary: Copy the contents of one redis db to another
 test_files:
+- spec/db/.gitkeep
 - spec/redis-copy/key-emitter_spec.rb
 - spec/redis-copy/strategy_spec.rb
-has_rdoc: 
+- spec/redis.spec.conf
+- spec/spec_helper.rb