redis-em-mutex 0.1.1 → 0.1.2

data/HISTORY.rdoc

@@ -1,3 +1,9 @@
+0.1.2
+- features macro-style definitions
+- fixed: setup with :redis
+- added macros spec
+- added more setup features spec
+
 0.1.1
 - fixed: namespaces didn't work
 - added namespaces spec

data/README.rdoc

@@ -20,6 +20,7 @@ Author::    Rafał Michalski  (mailto:rafal@yeondir.com)
 * fiber-safe
 * deadlock detection (only trivial cases: locking twice the same resource from the same fiber)
 * mandatory lock expiration (with refreshing)
+* macro-style definitions (Mutex::Macro mixin)
 
 == BUGS/LIMITATIONS
 
@@ -31,8 +32,8 @@ Author::    Rafał Michalski  (mailto:rafal@yeondir.com)
 == REQUIREMENTS
 
 * ruby >= 1.9 (tested: 1.9.3-p194, 1.9.2-p320, 1.9.1-p378)
-* http://github.com/redis/redis-rb >= 3.0.1
-* http://rubyeventmachine.com >= 0.12.10
+* http://github.com/redis/redis-rb ~> 3.0.1
+* http://rubyeventmachine.com ~> 1.0.0
 * (optional) http://github.com/igrigorik/em-synchrony
 
 == INSTALL
@@ -41,7 +42,7 @@ Author::    Rafał Michalski  (mailto:rafal@yeondir.com)
 
 ==== Gemfile
 
-  gem "redis-em-mutex", "~> 0.1.1"
+  gem "redis-em-mutex", "~> 0.1.2"
 
 ==== Github
 
@@ -100,7 +101,7 @@ Author::    Rafał Michalski  (mailto:rafal@yeondir.com)
 
   EM.synchrony do
     ns.synchronize('foo') do
-      .... do something with foo and bar
+      .... do something with foo
     end
     ...
     EM.stop
@@ -140,6 +141,54 @@ Author::    Rafał Michalski  (mailto:rafal@yeondir.com)
     EM.stop
   end
 
+=== Macro-style definition
+
+Borrowed from http://github.com/kenn/redis-mutex.
+Redis::EM::Mutex::Macro is a mixin which protects selected instance methods of a class with a mutex.
+The locking scope will be Mutex global namespace + class name + method name.
+
+  class TheClass
+    include Redis::EM::Mutex::Macro
+  
+    auto_mutex
+    def critical_run
+      ... do some critical stuff
+      ....only one fiber in one process on one machine is executing this instance method of any instance of defined class
+    end
+
+    auto_mutex expire: 100, ns: '**TheClass**'
+    # all critical methods defined later will inherit above options unless overridden
+  
+    auto_mutex # start and stop will be protected
+    def start
+      ...
+    end
+
+    def stop
+      ...
+    end
+
+    no_auto_mutex
+    def some_unprotected_method
+      ...
+    end
+
+    auto_mutex :run_long, expire: 100000, block: 10, on_timeout: :cant_run
+    def run_long
+      ...
+    end
+
+    def cant_run
+      ...
+    end
+
+    def foo
+      ...
+    end
+    auto_mutex :foo, block: 0, on_timeout: proc { puts 'bar!' }
+
+  end
+
 === Advanced
 
   mutex = Redis::EM::Mutex.new('resource1', 'resource2', expire: 60)

data/Rakefile

@@ -6,7 +6,9 @@ $gem_name = "redis-em-mutex"
 
 desc "Run spec tests"
 task :test do
-  sh "rspec spec/*.rb"
+  Dir["spec/#{$gem_name}-*.rb"].each do |spec|
+    sh "rspec #{spec}"
+  end
 end
 
 desc "Build the gem"

data/lib/redis/em-mutex/macro.rb

@@ -0,0 +1,123 @@
+class Redis
+  module EM
+    class Mutex
+      # Macro-style definition
+      #
+      # idea and some code borrowed from http://github.com/kenn/redis-mutex and enhanced
+      #
+      # class ClassWithCriticalMethods
+      #   include Redis::EM::Mutex::Macro
+      #
+      #   auto_mutex
+      #   def critical
+      #     ... do some critical stuff
+      #     ....only one fiber in one process on one machine is executing this instance method of any instance of defined class
+      #   end
+      # end
+      #
+      module Macro
+        def self.included(klass)
+          klass.extend ClassMethods
+          klass.class_eval do
+            class << self
+              attr_reader :auto_mutex_methods, :auto_mutex_options
+              attr_accessor :auto_mutex_enabled
+            end
+            @auto_mutex_methods = {}
+            @auto_mutex_options = {:ns => Redis::EM::Mutex.ns ? "#{Redis::EM::Mutex.ns}:#{klass.name}" : klass.name}
+            @auto_mutex_enabled = false
+          end
+        end
+
+        module ClassMethods
+          # auto_mutex [*method_names], [options]
+          #
+          # options are:
+          # - :expire - see Mutex.new
+          # - :block  - see Mutex.new
+          # - :ns     - custom namespace, if not present name of the class that includes Macro is used
+          # - :on_timeout - if defined, this proc/method will be called instead of raising MutexTimeout error
+          #
+          # If method_names are provided (names of already defined methods or defined in the future)
+          # they become protected with mutex.
+          #
+          # If options are provided wihout method_names, they will become default options
+          # for subsequent auto_mutex calls.
+          #
+          # If auto_mutex is called without arguments then any method further defined will also be protected.
+          # To disable implicit auto_mutex use no_auto_mutex.
+          def auto_mutex(*args)
+            options = args.last.kind_of?(Hash) ? args.pop : {}
+            if args.each {|target|
+                self.auto_mutex_methods[target] = self.auto_mutex_options.merge(options)
+                auto_mutex_method_added(target) if method_defined? target
+              }.empty?
+              if options.empty?
+                self.auto_mutex_enabled = true
+              else
+                self.auto_mutex_options.update(options)
+              end
+            end
+          end
+
+          # Switch off implicit auto_mutex.
+          # After calling no_auto_mutex if any new method is defined it won't be protected
+          # unless explicitely specified with auto_mutex.
+          def no_auto_mutex
+            self.auto_mutex_enabled = false
+          end
+
+          def method_added(target)
+            return if target.to_s =~ /_(?:with|without|on_timeout)_auto_mutex$/
+            return unless self.auto_mutex_methods[target] || self.auto_mutex_enabled
+            auto_mutex_method_added(target)
+          end
+
+          def auto_mutex_method_added(target)
+            without_method  = "#{target}_without_auto_mutex"
+            with_method     = "#{target}_with_auto_mutex"
+            timeout_method  = "#{target}_on_timeout_auto_mutex"
+            return if method_defined?(without_method)
+
+            options = self.auto_mutex_methods[target] || self.auto_mutex_options
+            mutex = nil
+
+            on_timeout = options[:on_timeout] || options[:after_failure]
+
+            if on_timeout.respond_to?(:call)
+              define_method(timeout_method, &on_timeout)
+            elsif on_timeout.is_a?(Symbol)
+              timeout_method = on_timeout
+            end
+
+            define_method(with_method) do |*args, &blk|
+              mutex||= Redis::EM::Mutex.new target, options
+              response = nil
+
+              begin
+                if mutex.refresh
+                  response = __send__(without_method, *args, &blk)
+                else
+                  mutex.synchronize do
+                    response = __send__(without_method, *args, &blk)
+                  end
+                end
+              rescue Redis::EM::Mutex::MutexTimeout => e
+                if respond_to?(timeout_method)
+                  response = __send__(timeout_method, *args, &blk)
+                else
+                  raise e
+                end
+              end
+
+              response
+            end
+
+            alias_method without_method, target
+            alias_method target, with_method
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redis/em-mutex/version.rb

@@ -0,0 +1,7 @@
+class Redis
+  module EM
+    class Mutex
+      VERSION = '0.1.2'
+    end
+  end
+end

data/lib/redis/em-mutex.rb

@@ -3,6 +3,7 @@ require 'ostruct'
 require 'securerandom'
 require 'redis/connection/synchrony' unless defined? Redis::Connection::Synchrony
 require 'redis'
+require 'redis/em-mutex/version'
 
 class Redis
   module EM
@@ -13,12 +14,15 @@ class Redis
     # Methods of this class are NOT thread-safe.
     # They are machine/process/fiber-safe.
     # All method calls must be invoked only from EventMachine's reactor thread.
+    # Wrap mutex calls in EventMachine.shedule from non-reactor threads.
     #
     # - The terms "lock" and "semaphore" used in documentation are synonims.
-    # - The term "owner" denotes a Ruby Fiber in some Process on some Machine.
+    # - The term "owner" denotes a Ruby Fiber executing code in the scope of Machine/Process/Fiber
+    #   possessing exclusively a named semaphore(s).
     #
     class Mutex
-      VERSION = '0.1.1'
+
+      autoload :Macro, 'redis/em-mutex/macro'
 
       module Errors
         class MutexError < RuntimeError; end
@@ -125,7 +129,8 @@ class Redis
         end
       end
 
-      # Returns `true` if this semaphore (all the locked `names`) is currently being held by calling fiber.
+      # Returns `true` if this semaphore (all the locked `names`) is currently being held by calling fiber
+      # (if executing fiber is the owner).
       def owned?
         !!if @locked_id
           lock_full_ident = owner_ident(@locked_id)
@@ -360,7 +365,7 @@ class Redis
             }.reject {|_k, v| v.nil?})
           end
           if (redis = opts.redis) && !opts.url
-            redis_updater.call redis
+            redis_updater.call redis.client
           elsif opts.url
             redis_options[:url] = opts.url
           end

data/lib/redis-em-mutex.rb

@@ -1,5 +1,9 @@
-class Redis
-  module EM
-    autoload :Mutex, 'redis/em-mutex'
+if defined?(Redis::EM::Mutex)
+  require 'redis/em-mutex'
+else
+  class Redis
+    module EM
+      autoload :Mutex, 'redis/em-mutex'
+    end
   end
 end

data/redis-em-mutex.gemspec

@@ -1,5 +1,5 @@
 $:.unshift "lib"
-require 'redis/em-mutex'
+require 'redis/em-mutex/version'
 
 Gem::Specification.new do |s|
   s.name = "redis-em-mutex"
@@ -18,11 +18,11 @@ Gem::Specification.new do |s|
     "--main" << "README.rdoc"
   s.has_rdoc = true
   s.extra_rdoc_files = ["README.rdoc"]
-  s.requirements << "Redis server"
-  s.add_runtime_dependency "redis", ">= 3.0.0"
+  s.requirements << "Redis server 2.4+"
+  s.add_runtime_dependency "redis", ">= 3.0.1"
   s.add_runtime_dependency "hiredis", "~> 0.4.5"
-  s.add_runtime_dependency "eventmachine", ">= 0.12.10"
+  s.add_runtime_dependency "eventmachine", ">= 1.0.0.beta.1"
   s.add_development_dependency "rspec", "~> 2.8.0"
-  s.add_development_dependency "eventmachine", ">= 1.0.0.beta.1"
+  s.add_development_dependency "eventmachine", "~> 1.0.0"
   s.add_development_dependency "em-synchrony", "~> 1.0.0"
 end

data/spec/redis-em-mutex-features.rb

@@ -1,5 +1,6 @@
 $:.unshift "lib"
 require 'em-synchrony'
+require 'em-synchrony/connection_pool'
 require 'redis-em-mutex'
 
 describe Redis::EM::Mutex do
@@ -18,6 +19,67 @@ describe Redis::EM::Mutex do
     }.to raise_error(described_class::MutexError, /Can not establish watcher channel connection!/)
   end
 
+  it "should setup with redis connection pool" do
+    described_class.setup(redis: @redis_pool)
+    described_class.class_variable_get(:'@@redis_pool').should be @redis_pool
+    redis = described_class.class_variable_get(:'@@redis_watcher')
+    described_class.stop_watcher
+    redis.should be_an_instance_of Redis
+    redis.client.host.should eq 'localhost'
+    redis.client.db.should eq 1
+    redis.client.scheme.should eq 'redis'
+  end
+
+  it "should setup with various options" do
+    described_class.setup do |cfg|
+      cfg.expire = 42 #   - sets global Mutex.default_expire 
+      cfg.ns = 'redis rulez!' #       - sets global Mutex.namespace
+      cfg.reconnect_max = -1 # - maximum num. of attempts to re-establish
+      cfg.url = 'redis://127.0.0.1/2'
+      cfg.size = 10
+    end
+    described_class.namespace.should eq 'redis rulez!'
+    described_class.default_expire.should eq 42
+    described_class.class_variable_get(:'@@connection_retry_max').should eq -1
+    redis_pool = described_class.class_variable_get(:'@@redis_pool')
+    redis_pool.should be_an_instance_of EM::Synchrony::ConnectionPool
+    redis_pool.should_not be @redis_pool
+    redis_pool.client.host.should eq '127.0.0.1'
+    redis_pool.client.db.should eq 2
+    redis_pool.client.port.should eq 6379
+    redis_pool.client.scheme.should eq 'redis'
+    redis = described_class.class_variable_get(:'@@redis_watcher')
+    described_class.stop_watcher
+    redis.should be_an_instance_of Redis
+    redis.client.host.should eq '127.0.0.1'
+    redis.client.db.should eq 2
+    redis.client.port.should eq 6379
+    redis.client.scheme.should eq 'redis'
+  end
+
+  it "should setup with separate redis options" do
+    described_class.setup do |cfg|
+      cfg.scheme = 'redis'
+      cfg.host = 'localhost'
+      cfg.port = 6379
+      cfg.db = 3
+    end
+    redis_pool = described_class.class_variable_get(:'@@redis_pool')
+    redis_pool.should be_an_instance_of EM::Synchrony::ConnectionPool
+    redis_pool.should_not be @redis_pool
+    redis_pool.client.host.should eq 'localhost'
+    redis_pool.client.db.should eq 3
+    redis_pool.client.port.should eq 6379
+    redis_pool.client.scheme.should eq 'redis'
+    redis = described_class.class_variable_get(:'@@redis_watcher')
+    redis.should be_an_instance_of Redis
+    described_class.stop_watcher
+    redis.client.host.should eq 'localhost'
+    redis.client.db.should eq 3
+    redis.client.port.should eq 6379
+    redis.client.scheme.should eq 'redis'  
+  end
+
   around(:each) do |testcase|
     @after_em_stop = nil
     ::EM.synchrony do
@@ -30,4 +92,7 @@ describe Redis::EM::Mutex do
     @after_em_stop.call if @after_em_stop
   end
 
+  before(:all) do
+    @redis_pool = EM::Synchrony::ConnectionPool.new(size: 10) { Redis.new url: 'redis://localhost/1' }
+  end
 end

data/spec/redis-em-mutex-macros.rb

@@ -0,0 +1,232 @@
+$:.unshift "lib"
+require 'securerandom'
+require 'em-synchrony'
+require 'em-synchrony/fiber_iterator'
+require 'redis-em-mutex'
+
+class Test
+  include Redis::EM::Mutex::Macro
+  auto_mutex :method5
+  def method1; end
+  auto_mutex
+  def method2; end
+  no_auto_mutex
+  def method3; end
+  def method4; end
+  def method5; end
+  auto_mutex :method4
+  def method6; end
+  auto_mutex :method6, :method7, block: 10, on_timeout: proc { }
+  def method7; end
+
+  auto_mutex block: 20
+
+  auto_mutex
+  def test(redis, key, value)
+    redis.set key, value
+    ::EM::Synchrony.sleep 0.1
+    redis.get key
+  end
+
+  def recursive(n=1, &blk)
+    if n < 10
+      recursive(n+1, &blk)
+    else
+      yield n
+    end
+  end
+
+  no_auto_mutex
+  def test_no_mutex(redis, key, value)
+    redis.set key, value
+    ::EM::Synchrony.sleep 0.1
+    redis.get key
+  end
+
+  auto_mutex :may_timeout, block: 0, on_timeout: proc { false }
+  def may_timeout; yield; end
+
+  auto_mutex :may_timeout_no_fallback, block: 0
+  def may_timeout_no_fallback; yield; end
+
+  auto_mutex :may_timeout_method_fallback, block: 0, on_timeout: :may_timeout_timed_out
+  def may_timeout_method_fallback; yield; end
+  def may_timeout_timed_out; false; end
+
+end
+
+describe Redis::EM::Mutex::Macro do
+
+  it "should define auto_mutex methods" do
+    Test.auto_mutex_methods.keys.should eq [:method5, :method4, :method6, :method7, :may_timeout,
+        :may_timeout_no_fallback, :may_timeout_method_fallback]
+    [:method5, :method2, :method4, :test, :recursive,
+        :may_timeout_no_fallback, :may_timeout_method_fallback].each do |name|
+      Test.method_defined?(name).should be_true
+      Test.method_defined?("#{name}_without_auto_mutex").should be_true
+      Test.method_defined?("#{name}_with_auto_mutex").should be_true
+      Test.method_defined?("#{name}_on_timeout_auto_mutex").should be_false
+    end
+    [:method6, :method7, :may_timeout].each do |name|
+      Test.method_defined?(name).should be_true
+      Test.method_defined?("#{name}_without_auto_mutex").should be_true
+      Test.method_defined?("#{name}_with_auto_mutex").should be_true
+      Test.method_defined?("#{name}_on_timeout_auto_mutex").should be_true
+    end
+    [:method1, :method3, :test_no_mutex, :may_timeout_timed_out].each do |name|
+      Test.method_defined?(name).should be_true
+      Test.method_defined?("#{name}_without_auto_mutex").should be_false
+      Test.method_defined?("#{name}_with_auto_mutex").should be_false
+      Test.method_defined?("#{name}_on_timeout_auto_mutex").should be_false
+    end
+  end
+
+  it "should method run unprotected" do
+    iterate = 10.times.map { Test.new }
+    test_key = @test_key
+    results = {}
+    ::EM::Synchrony::FiberIterator.new(iterate, iterate.length).each do |test|
+      begin
+        redis = Redis.new @redis_options
+        value = test.__id__.to_s
+        results[value] = test.test_no_mutex(redis, test_key, value)
+      rescue Exception => e
+        @exception = e
+      end
+    end
+    results.length.should eq iterate.length
+    results.each_pair do |k, v|
+      v.should eq results.values.last
+    end
+  end
+
+  it "should protect auto_mutex method" do
+    iterate = 10.times.map { Test.new }
+    test_key = @test_key
+    results = {}
+    ::EM::Synchrony::FiberIterator.new(iterate, iterate.length).each do |test|
+      begin
+        redis = Redis.new @redis_options
+        value = test.__id__.to_s
+        results[value] = test.test(redis, test_key, value)
+      rescue Exception => e
+        @exception = e
+      end
+    end
+    results.length.should eq iterate.length
+    results.each_pair do |k, v|
+      k.should eq v
+    end
+  end
+
+  it "should allow recursive calls to protected methods" do
+    iterate = 10.times.map { Test.new }
+    test_key = @test_key
+    results = {}
+    ::EM::Synchrony::FiberIterator.new(iterate, iterate.length).each do |test|
+      begin
+        redis = Redis.new @redis_options
+        value = test.__id__.to_s
+        results[value] = test.recursive do |n|
+          redis.set test_key, value
+          ::EM::Synchrony.sleep 0.1
+          [redis.get(test_key), n]
+        end
+      rescue Exception => e
+        @exception = e
+      end
+    end
+    results.length.should eq iterate.length
+    results.each_pair do |k, v|
+      v.should eq [k, 10]
+    end
+  end
+
+  it "should call on_timout lambda when locking times out" do
+    ::EM::Synchrony.next_tick do
+      begin
+        Test.new.may_timeout do
+          ::EM::Synchrony.sleep 0.2
+          true
+        end.should be_true
+      rescue Exception => e
+        @exception = e
+      end
+    end
+    ::EM::Synchrony.sleep 0.1
+    Test.new.may_timeout do
+      true
+    end.should be_false
+    ::EM::Synchrony.sleep 0.15
+  end
+
+  it "should raise MutexTimeout when locking times out" do
+    ::EM::Synchrony.next_tick do
+      begin
+        Test.new.may_timeout_no_fallback do
+          ::EM::Synchrony.sleep 0.2
+          true
+        end.should be_true
+      rescue Exception => e
+        @exception = e
+      end
+    end
+    ::EM::Synchrony.sleep 0.1
+    expect {
+      Test.new.may_timeout_no_fallback do
+        true
+      end
+    }.to raise_error(Redis::EM::Mutex::MutexTimeout)
+    ::EM::Synchrony.sleep 0.15
+  end
+
+  it "should call on_timout method when locking times out" do
+    ::EM::Synchrony.next_tick do
+      begin
+        Test.new.may_timeout_method_fallback do
+          ::EM::Synchrony.sleep 0.2
+          true
+        end.should be_true
+      rescue Exception => e
+        @exception = e
+      end
+    end
+    ::EM::Synchrony.sleep 0.1
+    Test.new.may_timeout_method_fallback do
+      true
+    end.should be_false
+    ::EM::Synchrony.sleep 0.15
+  end
+
+  around(:each) do |testcase|
+    @after_em_stop = nil
+    @exception = nil
+    ::EM.synchrony do
+      begin
+        testcase.call
+        raise @exception if @exception
+        Redis::EM::Mutex.stop_watcher(false)
+      rescue => e
+        Redis::EM::Mutex.stop_watcher(true)
+        raise e
+      ensure
+        ::EM.stop
+      end
+    end
+    @after_em_stop.call if @after_em_stop
+  end
+
+  before(:all) do
+    @redis_options = {:driver => :synchrony}
+    @test_key = SecureRandom.base64(24)
+    Redis::EM::Mutex.setup @redis_options.merge(size: 11, ns: SecureRandom.base64(15))
+  end
+
+  after(:all) do
+    ::EM.synchrony do
+      Redis.new(@redis_options).del @test_key
+      EM.stop
+    end
+    # @lock_names
+  end
+end

data/spec/redis-em-mutex-namespaces.rb

@@ -100,7 +100,7 @@ describe Redis::EM::Mutex do
   end
 
   before(:all) do
-    @redis_options = {}
+    @redis_options = {:driver => :synchrony}
     described_class.setup @redis_options.merge(size: 11)
     @lock_names = 10.times.map {
       SecureRandom.random_bytes

data/spec/redis-em-mutex-semaphores.rb

@@ -323,7 +323,7 @@ describe Redis::EM::Mutex do
       begin
         testcase.call
         raise @exception if @exception
-        described_class.stop_watcher(false)
+        described_class.stop_watcher
       rescue => e
         described_class.stop_watcher(true)
         raise e
@@ -335,7 +335,7 @@ describe Redis::EM::Mutex do
   end
 
   before(:all) do
-    @redis_options = {}
+    @redis_options = {:driver => :synchrony}
     described_class.setup @redis_options.merge(size: 11)
     @lock_names = 10.times.map {
       SecureRandom.random_bytes

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-em-mutex
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-12 00:00:00.000000000 Z
+date: 2012-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &254270740 !ruby/object:Gem::Requirement
+  requirement: &90657860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.0.1
   type: :runtime
   prerelease: false
-  version_requirements: *254270740
+  version_requirements: *90657860
 - !ruby/object:Gem::Dependency
   name: hiredis
-  requirement: &254270280 !ruby/object:Gem::Requirement
+  requirement: &90657060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,21 +32,21 @@ dependencies:
         version: 0.4.5
   type: :runtime
   prerelease: false
-  version_requirements: *254270280
+  version_requirements: *90657060
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &254269820 !ruby/object:Gem::Requirement
+  requirement: &90656280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.12.10
+        version: 1.0.0.beta.1
   type: :runtime
   prerelease: false
-  version_requirements: *254269820
+  version_requirements: *90656280
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &254269360 !ruby/object:Gem::Requirement
+  requirement: &90655560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,21 +54,21 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *254269360
+  version_requirements: *90655560
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &254268900 !ruby/object:Gem::Requirement
+  requirement: &90654360 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 1.0.0.beta.1
+        version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *254268900
+  version_requirements: *90654360
 - !ruby/object:Gem::Dependency
   name: em-synchrony
-  requirement: &254268440 !ruby/object:Gem::Requirement
+  requirement: &90652800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,7 +76,7 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *254268440
+  version_requirements: *90652800
 description: Cross server-process-fiber EventMachine + Redis based semaphore with
   many features
 email: rafal@yeondir.com
@@ -90,8 +90,11 @@ files:
 - Rakefile
 - lib/redis-em-mutex.rb
 - lib/redis/em-mutex.rb
+- lib/redis/em-mutex/macro.rb
+- lib/redis/em-mutex/version.rb
 - redis-em-mutex.gemspec
 - spec/redis-em-mutex-features.rb
+- spec/redis-em-mutex-macros.rb
 - spec/redis-em-mutex-namespaces.rb
 - spec/redis-em-mutex-semaphores.rb
 homepage: http://github.com/royaltm/redis-em-mutex
@@ -117,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- Redis server
+- Redis server 2.4+
 rubyforge_project: 
 rubygems_version: 1.8.17
 signing_key: 
@@ -127,3 +130,4 @@ test_files:
 - spec/redis-em-mutex-namespaces.rb
 - spec/redis-em-mutex-semaphores.rb
 - spec/redis-em-mutex-features.rb
+- spec/redis-em-mutex-macros.rb