me-redis 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a72bf4245ee1c3efe20256d83c4999e0002d78ea
-  data.tar.gz: 02acdfc1108cc6a3e06b04885b901fa1b63e7c95
+SHA256:
+  metadata.gz: 42d0534ff1e6462c1ada7d35f277b4eae482285d19df0678542cc9e21f78d5f5
+  data.tar.gz: 56b06010bba70a0694f1ecd6d6b90147dff50af4281bc6a4993b9985ad6ccf2b
 SHA512:
-  metadata.gz: cc66f942a6f49e9c86678ee7f92fdd2dbac60edd77df7b2a7feecde527769a0629da6f06b2d52bd7f5e9c1d9d9ac96a5905bc3ee17658e75d90336d31b5978e4
-  data.tar.gz: 5e699108252163cda89cfd604189343ad38c91a4dc4908d0aaefc890690415109ac6aa8d144a4846b350d20ffaf4e79c09292405fc69c3dffa30731ef6db7db9
+  metadata.gz: af8c922ef45eaf8a89a39bf840e92115c21f2fca4886add3d9b4a219d5e8ce8bb989be4dd7f3b20cee3170c43978ad9d71260140092d12dd6bc0161de767c010
+  data.tar.gz: e5882c9e5e905a8e457668b569140d0ec678eb81eb6de0c54249e073ca2f8dc7abdc42dce10613a2aaeaa53325194f4fcaaf947ec897b7bedf43093aedaad831

data/.travis.yml

@@ -1,4 +1,7 @@
 language: ruby
 rvm:
-  - 2.1.6
-before_install: gem install bundler -v 1.10.6
+  - 2.4.4
+  - 2.5.1
+
+services:
+  - redis-server

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# 0.1.2
+* add AwsConfigBlocker extension. Prepending MeRedis successor with this module 
+prevents error while using the MeRedis with AWS ElasticCache (AWS blocks all config calls).
+
+* added docker-compose for local testing comfort 
+
+# 0.1.1
+* add MockRedis extension 

data/Dockerfile

@@ -0,0 +1,6 @@
+FROM ruby:2.5
+
+WORKDIR me-redis
+
+ADD . /me-redis/
+RUN bundle install

data/README.md

@@ -5,21 +5,19 @@ Me - Memory Efficient
 This gem is delivering memory optimizations for Redis with slightest code changes.
 
 To understand optimizations and how to use them 
-I suggest you to read my paper this topic: https://medium.com/p/61076c7da4c
+I suggest you to read my paper: https://medium.com/@leshchuk/zipem-all-61076c7da4c
 
-#Features:
+Compatibility: ruby >= 2.4, redis gem >= 3.0.4
+
+## Features:
  
-* seamless integration with code already in use, hardest integration possible: 
-add me_ prefix to some of your methods ( me_ methods implement hash memory optimization ). 
-It's all in MeRedis configuration, not your current code. 
+* seamless integration with code already in use. **It's all in MeRedis configuration, not your current code.** 
 
-* hash key/value optimization with seamless code changes, 
-you can replace set('object:id', value) with me_set( 'object:id', value) 
-and free 90 byte for each ['object:id', value] pair. 
+* hash key/value optimization with seamless code changes, just replace set('object:id', value) with me_set( 'object:id', value) and free upto 90 bytes for each ['object:id', value] pair. 
 
 * zips user-friendly key crumbs according to configuration, i.e. converts for example user:id to u:id
 
-* zip integer parts of a keys with base62 encoding. Since all keys in redis are always strings, than we don't care for integers parts base, and by using base62 encoding we can 1.8 times shorten integer crumbs of keys 
+* zip integer parts of keys with base62 encoding. Since all keys in redis are always strings, than we don't care for integer parts base, and by using base62 encoding we can shorten them upto 1.8 times shorter  
 
 * respects pipelined and multi, properly works with Futures. 
 
@@ -55,7 +53,9 @@ Or install it yourself as:
 1) less memory on redis side is better than less performance on ruby side
 2) more result with less code changes,
    i.e. overriding native redis methods with proper configuration basis is 
-   preferred over mixin new methods
+   preferred over mixin new methods. 
+   
+I wanted magic to happend: mix all kind of optimizations without making 3 call of different methods.   
 
 MeRedis based on three general optimization ideas:
 * shorten keys
@@ -73,7 +73,7 @@ way to deal with them all is call include upon MeRedis:
    redis = Redis.new
 ``` 
 
-If you want to keep a clear Redis class, you can do this way:
+If you want to keep a clear Redis class, you can do it this way:
 
 ```ruby
    me_redis = Class.new(Redis).include(MeRedis).configure({...}).new
@@ -94,7 +94,22 @@ If you want to include them separately look at MeRedis.included method:
 
 This is the right chain of prepending/including, so just remove unnecessary module.
 
-###Base use
+### AWS ElasticCache usage
+
+AWS blocks config call with exception. To prevent this behaviour prepend MeRedis successor 
+with AwsConfigBlocker module:
+
+```ruby
+Class.new(Redis)
+     .include(MeRedis)
+     .prepend( MeRedis::AwsConfigBlocker )
+     .configure({
+       # some config
+     }).new
+```
+
+
+### Base use
 
 ```ruby
   redis = Redis.new
@@ -133,9 +148,9 @@ This is the right chain of prepending/including, so just remove unnecessary modu
 
 As you can see you can get a result with smallest or even none code changes!
 
-All the ideas is to move complexity to config.
+The idea is to move complexity to config.
    
-###Config
+### Config
 ```ruby
 
   Redis.include(MeRedis).configure( hash_max_ziplist_entries: 512 ) 
@@ -151,9 +166,9 @@ All the ideas is to move complexity to config.
     :hash_max_ziplist_value
      
     # array or hash or string/sym of keys crumbs to zip, 
-    # if a hash given it used as is,
+    # when a hash is given it used as is,
     # otherwise MeRedis tries to construct hash by using first char from each key given 
-    # + integer in base62 starting from 1 for subsequent appearence of a crumbs starting with same chars
+    # + integer in base62 starting from 1 for subsequent appearence of a crumbs starting with same char
     :zip_crumbs
     
     # set to true if you want to zip ALL integers in keys to base62 form
@@ -183,7 +198,7 @@ All the ideas is to move complexity to config.
     # any kind of object which responds to compress/decompress methods
     :default_compressor
 ```
-  ###Config examples
+  ### Config examples
   
 ```ruby
 
@@ -250,8 +265,8 @@ Redis.configure(
   integers_to_base62: true,
   zip_crumbs: %i[user card card_preview organization], # -> { user: :u, card: :c, card_preview: :c1, organization: :o }
   compress_namespaces: {
-      /o:[a-zA-Z\d]+:card_preview/ => MeRedis::ZipValues::ZlibCompressor,
-      [:user, :card].map{|crumb| /o:[a-zA-Z\d]+:#{crumb}/ } => ActiveRecordJSONCompressor 
+      /o:[a-zA-Z\d]+:c1/ => MeRedis::ZipValues::ZlibCompressor,
+      [:u, :c].map{|crumb| /o:[a-zA-Z\d]+:#{crumb}/ } => ActiveRecordJSONCompressor 
   }
 )
 
@@ -276,20 +291,24 @@ Redis.configure(
   compress_namespaces: %i[user card card_preview]
 )
 ```
+### Config best practices
 Now I may suggest some best practices for MeRedis configure:
 
 * explicit crumbs schema is preferable over implicit
-* if you are going lazy, and use implicit schemas, than avoid keys shuffling, 
+* if you are going lazy, and use implicit schemas, than avoid keys reshuffling, 
   cause it messes with your cache
-* better to configure hash-max-ziplist-* in MeRedis.configure than elsewhere.
-* use in persistent Redis-based system with extreme caution
+* better to configure hash-max-ziplist-* in MeRedis.configure than 
+  elsewhere. And don't forget - this will reset them globally 
+  for this Redis server!
+* use MeRedis in persistent Redis-based system with extreme caution!
+
   
  
-#Custom Compressors
+# Custom Compressors
 
 MeRedis allow you to compress values through different compressor. 
 Here is an example of custom compressor for ActiveRecord objects, 
-I use to test compression ratio against plain compression of to_json. 
+I use it to test compression ratio against plain compression of to_json. It takes ~40% less memory than Zlib.deflate(object.to_json). 
 
 ```ruby
 
@@ -299,7 +318,7 @@ module ActiveRecordJSONCompressor
   # like User: { first_name: 1, last_name: 2 ... }, 
   # than your cache will be safer on schema changes.
   COMPRESSOR_SCHEMAS = [User, HTag].map{|mdl|
-    [mdl.to_s, mdl.column_names.each_with_index.map{ |el, i| [el, (20 + i).to_base62] }.to_h]
+    [mdl.to_s, mdl.column_names.each_with_index.map{ |el, i| [el, i.to_base62] }.to_h]
   }.to_h.with_indifferent_access
 
   REVERSE_COMPRESSOR_SCHEMA = COMPRESSOR_SCHEMAS.dup.transform_values(&:invert)
@@ -326,20 +345,21 @@ end
 
 ```
 
-#Hot migration 
-MeRedis deliver additional module for hot migration to KeyZipping and ZipToHash. 
-We don't need one in generally for base implementation of ZipValues cause 
-its getter methods fallbacks to value. 
+# Hot migration 
+MeRedis deliver additional module MeRedisHotMigrator for hot migration to KeyZipping and ZipToHash. 
 
-###Features
-* mget hget hgetall get exists type getset - fallbacks for key_zipping
-* me_get me_mget - fallbacks for hash zipping
+We don't need one in generally for base implementation of ZipValues module cause 
+its getter methods fallbacks to values. 
+
+### Features
+* mget hget hgetall get exists type getset - fallbacks to original methods for key_zipping
+* me_get me_mget - fallbacks to original methods for hash zipping
 * partially respects pipelining and multi 
 * protecting you from accidentally do many to less many migration 
   and from ZipToHash migration without key zipping ( 
     though it's impossible to hot migrate from 'user:100' to 'user:1', 'B', 
     because of same namespace 'user' for flat key/value pair and hashes, 
-    you'll definetely get an error ) 
+    you'll definetely get an error from Redis ) 
 * reverse migration methods
 
 ```ruby
@@ -350,42 +370,59 @@ its getter methods fallbacks to value.
   usr_1_cache = redis.me_get('user:1')
   
   all_user_keys = redis.keys('user*') 
+  # it doesn't delete all_user_keys!!! they still all in the Redis
   redis.migrate_to_hash_representation( all_user_keys )
-  
   usr_1_cache == redis.me_get('user:1') # true
   
+  redis.del( *all_user_keys )
+  # now you a ready to measure memory bonus you've got
+  ap redis.info(:memory)
+  
+  usr_1_cache == redis.me_get('user:1') # true
+    
   redis.reverse_from_hash_representation!( all_user_keys )
   
   usr_1_cache == redis.me_get('user:1') # true
-
 ```
 
 For persistent store use with extreme caution!! 
-Backup, test, test, user test and after you are sure than you may migrate. 
+Backup, test, test, user test and after you are completely sure than you may migrate. 
 
-Try not to stuck with it because doing double amount of actions, 
-do BG deploy of code, run migration in parallel, replace MeRedisHotMigrator with MeRedis
-do BG deploy and you are done. 
+Try not to stuck with MeRedisHotMigrator because it doing double amount of actions: 
+ 
+ 1. do BG deploy of code with MeRedisHotMigrator, 
+ 2. run migration in parallel, 
+ 3. replace MeRedisHotMigrator with MeRedis
+ 4. do BG deploy 
+ 
+ and you are done. 
+ 
+# Debug and broken expectations
+
+1. Check if modules you using override appropriate method ( if not make issue :) )
+2. Check the order of prepending / including modules ( look into MeRedis.included to see how things must be done ) 
+3. Call ap Redis.me_config and check it over your expectation, 
+   mistakes are usually in config. Don't forget - namespaces inside regexp must be in zipped form ( integers became base62 integers strings and crumbs are zipped )!
+4. Check hash-max-size-value, if your average data size is greater 
+   than hash-max-size-value than hash optimization will not bring resource savings.
+5. Check hash-max-size-entries if it small than hash effect is less than expected
+5. Trace through code and inspect zip_key and zip? output.  
 
-#Limitations
+# Limitations
 
-###Me_* methods limitation
+### Me_* methods limitation
 
 Some of me_methods like me_mget/me_mset/me_getset 
-are imitations for corresponded base methods behaviour through 
+are imitations for corresponded Redis base methods behaviour through 
 pipeline and transactions. So inside pipelined call it may not 
 deliver a completely equal behaviour. 
 
-me_mget has an additional double me_mget_p in case you need to use it with futures. 
+me_mget has a method double me_mget_p in case you need to use it with futures. 
 
-###ZipKeys and ZipValues
+### ZipKeys and ZipValues
 As I already mention if you want to use custom prefix regex 
 for zipping values than it must be constructed with a crumbs substitutions, 
 not the original crumb, see config example. 
-
-```ruby
-
-```
                  
 ## Development
 
@@ -393,6 +430,31 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+## Testing
+
+```bash
+docker-compose build
+docker-compose run test
+```
+
+### MockRedis
+
+If you are using in mock_redis gem for testing purpose and see some test 
+breakage me-redis has a MockRedis extended class.
+Its imitate single DB for all instances of MockRedis class 
+and add some methods MeRedis rely upon. Its not a complete replacement 
+for Redis class, but you can try it out.
+ 
+
+### RedisSafety
+ MeRedis tests itself against RedisSafety class which is a Redis descendant class. 
+ All instances of RedisSafety ensure that Redis DB is empty otherwise they will raise an error. 
+ This is a precaution measure to prevent you from accidentally run MeRedis test again production DB.
+ 
+```
+  rake test REDIS_TEST_DB=5
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/alekseyl/me-redis.
@@ -404,5 +466,6 @@ The gem is available as open source under the terms of the [MIT License](http://
 
 ## ToDo List
 
+* add warning option for hash-max-ziplist-value overthrowing
 * add keys method 
-* refactor readme
+* refactor readme

data/docker-compose.yml

@@ -0,0 +1,17 @@
+version: "3.7"
+services:
+  redis:
+    image: redis
+    ports:
+      - "6379"
+
+  test:
+    build: .
+    image: me-redis-test
+    command: bundle exec rake test
+    volumes:
+      - '.:/me-redis'
+    depends_on:
+      - redis
+    environment:
+      REDIS_URL: redis://redis:6379

data/lib/me_redis.rb

@@ -5,7 +5,7 @@ require 'me_redis/zip_values'
 require 'me_redis/me_redis_hot_migrator'
 require 'me_redis/integer'
 require 'me_redis/hash'
-
+require 'me_redis/aws_config_blocker'
 require 'zlib'
 
 # Main ideas:
@@ -140,28 +140,27 @@ module MeRedis
     end
 
     def prepare_compressors
-
       me_config.default_compressor ||= MeRedis::ZipValues::EmptyCompressor
 
       me_config.compress_namespaces = case me_config.compress_namespaces
-                                        when Array
-                                          me_config.compress_namespaces.map{|ns| [replace_ns(ns), me_config.default_compressor] }.to_h
-                                        when String, Symbol, Regexp
-                                          { replace_ns( me_config.compress_namespaces ) => me_config.default_compressor }
-                                        when Hash
-                                          me_config.compress_namespaces.inject({}) do |sum, (name_space, compressor)|
-                                            name_space.is_a?( Array ) ?
-                                                sum.merge!( name_space.map{ |ns| [replace_ns( ns), compressor] }.to_h )
-                                                : sum[replace_ns(name_space)] = compressor
-                                            sum
-                                          end
-                                        else
-                                          raise ArgumentError.new(<<~NS_ERR) if me_config.compress_namespaces
+        when Array
+          me_config.compress_namespaces.map{|ns| [replace_ns(ns), me_config.default_compressor] }.to_h
+        when String, Symbol, Regexp
+          { replace_ns( me_config.compress_namespaces ) => me_config.default_compressor }
+        when Hash
+          me_config.compress_namespaces.inject({}) do |sum, (name_space, compressor)|
+          name_space.is_a?( Array ) ?
+              sum.merge!( name_space.map{ |ns| [replace_ns( ns), compressor] }.to_h )
+              : sum[replace_ns(name_space)] = compressor
+          sum
+          end
+        else
+          raise ArgumentError.new(<<~NS_ERR) if me_config.compress_namespaces
             Wrong class for compress_namespaces, expected Array, 
-                                Hash, String or Symbol! Got: #{me_config.compress_namespaces.class.to_s}
-                                          NS_ERR
-                                          {}
-                                      end
+            Hash, String or Symbol! Got: #{me_config.compress_namespaces.class.to_s}
+          NS_ERR
+          {}
+        end
 
       zip_ns_finder
     end

data/lib/me_redis/aws_config_blocker.rb

@@ -0,0 +1,30 @@
+require 'ap'
+module MeRedis
+  # how to use:
+  # Redis.include( MeRedis::AwsConfigBlocker )
+  module AwsConfigBlocker
+
+     def config( *args, &block )
+      print <<AWS_MSG
+     
+      \e[0;33;31;1m!!!!!!!!! MeRedis AWS CONFIG BLOCKER WARNING!!!!!! \e[0;33;31;0m
+      You introduced AwsConfigBlocker into the ancestors chain, that means that you intend to skip Redis config call,
+      because AWS does not support config get/set calls by throwing an exception. 
+      AwsConfigBlocker will block config call from reaching your Redis server!
+
+      You are calling config with arguments:
+
+AWS_MSG
+
+       ap args
+
+       print <<END_MSG
+       
+
+       Don't forget to setup redis param group with exact values, or you might face unexpected optimization degradation. 
+       You can find more details in the README section.
+END_MSG
+       {}
+    end
+  end
+end

data/lib/me_redis/hash.rb

@@ -1,3 +1,4 @@
+# ruby 2.3 support
 class Hash
   # Returns a new hash with all keys converted using the +block+ operation.
   #
@@ -26,4 +27,5 @@ class Hash
     end
     self
   end
+
 end unless Hash.method_defined?(:transform_keys)

data/lib/me_redis/version.rb

@@ -1,3 +1,3 @@
 module MeRedis
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

data/lib/me_redis/zip_keys.rb

@@ -28,7 +28,6 @@ module MeRedis
     def hmget( key, *args ); super( zip_key(key), *args ) end
     #---- Hash methods END --------------------
 
-
     def incr( key ); super( zip_key(key) ) end
     def get( key ); super( zip_key(key) ) end
 

data/lib/me_redis/zip_to_hash.rb

@@ -30,8 +30,8 @@ module MeRedis
     end
 
     def self.included(base)
-      base.extend( MeRedis::ClassMethods )
-      base.prepend( PrependMethods )
+      base.extend(MeRedis::ClassMethods)
+      base.prepend(PrependMethods)
     end
 
     def me_del( *keys )

data/lib/me_redis/zip_values.rb

@@ -1,6 +1,6 @@
 module MeRedis
-  # todo warn in development that gzipped size iz bigger than strict
-  # use prepend for classes or extend on instances
+  # todo warn in development when gzipped size iz bigger than strict
+  # use prepend for classes
   module ZipValues
     module FutureUnzip
       def set_transformation(&block)
@@ -10,7 +10,7 @@ module MeRedis
         @old_transformation = @transformation
         @transformation = -> (vl) {
           if @old_transformation
-            @old_transformation.call( block.call(vl, self) )
+            @old_transformation.call(block.call(vl, self))
           else
             block.call(vl, self)
           end
@@ -19,50 +19,9 @@ module MeRedis
       end
 
       # patch futures we need only when we are returning values, usual setters returns OK
-      COMMANDS = %i[ incr incrby hincrby get hget getset mget hgetall ].map{|cmd| [cmd, true]}.to_h
+      COMMANDS = %i[incr incrby hincrby get hget getset mget hgetall].map{ |cmd| [cmd, true]}.to_h
     end
 
-    module PrependMethods
-      def pipelined( &block )
-        super do |redis|
-          block.call(redis)
-          _patch_futures(@client)
-        end
-      end
-
-      def multi( &block )
-        super do |redis|
-          block.call(redis)
-          _patch_futures(@client)
-        end
-      end
-
-      def _patch_futures(client)
-        client.futures.each do |ftr|
-
-          ftr.set_transformation do |vl|
-            if vl && FutureUnzip::COMMANDS[ftr._command[0]]
-              # we only dealing here with GET methods, so it could be hash getters or get/mget
-              keys = ftr._command[0][0] == 'h' ? ftr._command[1,1] : ftr._command[1..-1]
-              if ftr._command[0] == :mget
-                vl.each_with_index.map{ |v, i| zip?(keys[i]) ? self.class.get_compressor_for_key(keys[i]).decompress( v ) : v }
-              elsif zip?(keys[0])
-                compressor = self.class.get_compressor_for_key(keys[0])
-                # on hash commands it could be an array
-                vl.is_a?(Array) ? vl.map!{|v| compressor.decompress( v ) } : compressor.decompress(vl)
-              else
-                vl
-              end
-            else
-              vl
-            end
-          end
-
-        end
-      end
-    end
-
-
     module ZlibCompressor
       def self.compress(value); Zlib.deflate(value.to_s ) end
 
@@ -78,23 +37,53 @@ module MeRedis
       def self.decompress(value); value end
     end
 
-    # for the global gzipping
     def self.prepended(base)
       base::Future.prepend(FutureUnzip)
-      base.prepend(PrependMethods)
 
-      base.extend( MeRedis::ClassMethods )
-      base.me_config.default_compressor = MeRedis::ZipValues::ZlibCompressor
+      base.extend(MeRedis::ClassMethods)
+
+      base.me_config.default_compressor = ::MeRedis::ZipValues::ZlibCompressor
     end
-    # for object extending
-    def self.included(base)
-      base::Future.prepend(FutureUnzip)
-      base.prepend(PrependMethods)
 
-      base.extend( MeRedis::ClassMethods )
-      base.me_config.default_compressor = MeRedis::ZipValues::ZlibCompressor
+    def pipelined(&block)
+      super do |redis|
+        block.call(redis)
+        _patch_futures(@client)
+      end
+    end
+
+    def multi(&block)
+      super do |redis|
+        block.call(redis)
+        _patch_futures(@client)
+      end
+    end
+
+    def _patch_futures(client)
+      client.futures.each do |ftr|
+
+        ftr.set_transformation do |vl|
+          if vl && FutureUnzip::COMMANDS[ftr._command[0]]
+            # we only dealing here with GET methods, so it could be hash getters or get/mget
+            keys = ftr._command[0][0] == 'h' ? ftr._command[1, 1] : ftr._command[1..-1]
+            if ftr._command[0] == :mget
+              vl.each_with_index.map{ |v, i| zip?(keys[i]) ? self.class.get_compressor_for_key(keys[i]).decompress( v ) : v }
+            elsif zip?(keys[0])
+              compressor = self.class.get_compressor_for_key(keys[0])
+              # on hash commands it could be an array
+              vl.is_a?(Array) ? vl.map!{ |v| compressor.decompress(v) } : compressor.decompress(vl)
+            else
+              vl
+            end
+          else
+            vl
+          end
+        end
+
+      end
     end
 
+
     def zip_value(value, key )
       zip?(key) ? self.class.get_compressor_for_key(key).compress( value ) : value
     end

data/me-redis.gemspec

@@ -29,8 +29,11 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'redis', '>= 3.0'
   spec.add_dependency 'base62-rb'
+  spec.add_dependency "awesome_print"
 
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest"
+  spec.add_development_dependency "pry-byebug"
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: me-redis
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - alekseyl
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-23 00:00:00.000000000 Z
+date: 2019-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  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: Enable to zip keys, zip values and replace simple storage key/value pairs
   with hash storing
 email:
@@ -89,18 +117,18 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- ".idea/me-redis.iml"
-- ".idea/misc.xml"
-- ".idea/modules.xml"
-- ".idea/workspace.xml"
 - ".travis.yml"
+- CHANGELOG.md
+- Dockerfile
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
+- docker-compose.yml
 - lib/me_redis.rb
+- lib/me_redis/aws_config_blocker.rb
 - lib/me_redis/hash.rb
 - lib/me_redis/integer.rb
 - lib/me_redis/me_redis_hot_migrator.rb
@@ -130,7 +158,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.7.9
 signing_key: 
 specification_version: 4
 summary: Memory efficient redis extention